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 #include <stdint.h>
  25 #include <string.h>
  26 #include <glib.h>
  27 #include <glib/gstdio.h>
  28 #include <stdio.h>
  29 #include <errno.h>
  30 #include <math.h>
  31 #include <inttypes.h>
  32 #include <libsigrok/libsigrok.h>
  33 #include "libsigrok-internal.h"
  34 #include "protocol.h"
  35
  36 #define UC_FIRMWARE     "kingst-la-%04x.fw"
  37 #define FPGA_FW_LA2016  "kingst-la2016-fpga.bitstream"
  38 #define FPGA_FW_LA2016A "kingst-la2016a1-fpga.bitstream"
  39
  40 #define MAX_SAMPLE_RATE  SR_MHZ(200)
  41 #define MAX_SAMPLE_DEPTH 10e9
  42 #define MAX_PWM_FREQ     SR_MHZ(20)
  43 #define PWM_CLOCK        SR_MHZ(200)
  44
  45 /* usb vendor class control requests to the cypress FX2 microcontroller */
  46 #define CMD_EEPROM      0xa2    /* ctrl_in reads, ctrl_out writes */
  47 #define CMD_FPGA_INIT   0x50    /* used before and after FPGA bitstream loading */
  48 #define CMD_FPGA_SPI    0x20    /* access registers in the FPGA over SPI bus, ctrl_in reads, ctrl_out writes */
  49 #define CMD_FPGA_ENABLE 0x10
  50 #define CMD_BULK_RESET  0x38    /* flush FX2 usb endpoint 6 IN fifos */
  51 #define CMD_BULK_START  0x30    /* begin transfer of capture data via usb endpoint 6 IN */
  52 #define CMD_KAUTH       0x60    /* communicate with authentication ic U10, not used */
  53
  54 /*
  55  * fpga spi register addresses for control request CMD_FPGA_SPI:
  56  * There are around 60 byte-wide registers within the fpga and
  57  * these are the base addresses used for accessing them.
  58  * On the spi bus, the msb of the address byte is set for read
  59  * and cleared for write, but that is handled by the fx2 mcu
  60  * as appropriate. In this driver code just use IN transactions
  61  * to read, OUT to write.
  62  */
  63 #define REG_RUN         0x00    /* read capture status, write capture start */
  64 #define REG_PWM_EN      0x02    /* user pwm channels on/off */
  65 #define REG_CAPT_MODE   0x03    /* set to 0x00 for capture to sdram, 0x01 bypass sdram for streaming */
  66 #define REG_BULK        0x08    /* write start address and number of bytes for capture data bulk upload */
  67 #define REG_SAMPLING    0x10    /* write capture config, read capture data location in sdram */
  68 #define REG_TRIGGER     0x20    /* write level and edge trigger config */
  69 #define REG_THRESHOLD   0x68    /* write two pwm configs to control input threshold dac */
  70 #define REG_PWM1        0x70    /* write config for user pwm1 */
  71 #define REG_PWM2        0x78    /* write config for user pwm2 */
  72
  73 static int ctrl_in(const struct sr_dev_inst *sdi,
  74                    uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
  75                    void *data, uint16_t wLength)
  76 {
  77         struct sr_usb_dev_inst *usb;
  78         int ret;
  79
  80         usb = sdi->conn;
  81
  82         if ((ret = libusb_control_transfer(
  83                      usb->devhdl, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN,
  84                      bRequest, wValue, wIndex, (unsigned char *)data, wLength,
  85                      DEFAULT_TIMEOUT_MS)) != wLength) {
  86                 sr_err("failed to read %d bytes via ctrl-in %d %#x, %d: %s.",
  87                        wLength, bRequest, wValue, wIndex,
  88                        libusb_error_name(ret));
  89                 return SR_ERR;
  90         }
  91
  92         return SR_OK;
  93 }
  94
  95 static int ctrl_out(const struct sr_dev_inst *sdi,
  96                     uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
  97                     void *data, uint16_t wLength)
  98 {
  99         struct sr_usb_dev_inst *usb;
 100         int ret;
 101
 102         usb = sdi->conn;
 103
 104         if ((ret = libusb_control_transfer(
 105                      usb->devhdl, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT,
 106                      bRequest, wValue, wIndex, (unsigned char*)data, wLength,
 107                      DEFAULT_TIMEOUT_MS)) != wLength) {
 108                 sr_err("failed to write %d bytes via ctrl-out %d %#x, %d: %s.",
 109                        wLength, bRequest, wValue, wIndex,
 110                        libusb_error_name(ret));
 111                 return SR_ERR;
 112         }
 113
 114         return SR_OK;
 115 }
 116
 117 static int upload_fpga_bitstream(const struct sr_dev_inst *sdi, const char *bitstream_fname)
 118 {
 119         struct dev_context *devc;
 120         struct drv_context *drvc;
 121         struct sr_usb_dev_inst *usb;
 122         struct sr_resource bitstream;
 123         uint8_t buffer[sizeof(uint32_t)];
 124         uint8_t *wrptr;
 125         uint8_t cmd_resp;
 126         uint8_t block[4096];
 127         int len, act_len;
 128         unsigned int pos;
 129         int ret;
 130         unsigned int zero_pad_to = 0x2c000;
 131
 132         devc = sdi->priv;
 133         drvc = sdi->driver->context;
 134         usb = sdi->conn;
 135
 136         sr_info("Uploading FPGA bitstream '%s'.", bitstream_fname);
 137
 138         ret = sr_resource_open(drvc->sr_ctx, &bitstream, SR_RESOURCE_FIRMWARE, bitstream_fname);
 139         if (ret != SR_OK) {
 140                 sr_err("could not find fpga firmware %s!", bitstream_fname);
 141                 return ret;
 142         }
 143
 144         devc->bitstream_size = (uint32_t)bitstream.size;
 145         wrptr = buffer;
 146         write_u32le_inc(&wrptr, devc->bitstream_size);
 147         if ((ret = ctrl_out(sdi, CMD_FPGA_INIT, 0x00, 0, buffer, wrptr - buffer)) != SR_OK) {
 148                 sr_err("failed to give upload init command");
 149                 sr_resource_close(drvc->sr_ctx, &bitstream);
 150                 return ret;
 151         }
 152
 153         pos = 0;
 154         while (1) {
 155                 if (pos < bitstream.size) {
 156                         len = (int)sr_resource_read(drvc->sr_ctx, &bitstream, &block, sizeof(block));
 157                         if (len < 0) {
 158                                 sr_err("failed to read from fpga bitstream!");
 159                                 sr_resource_close(drvc->sr_ctx, &bitstream);
 160                                 return SR_ERR;
 161                         }
 162                 } else {
 163                         // fill with zero's until zero_pad_to
 164                         len = zero_pad_to - pos;
 165                         if ((unsigned)len > sizeof(block))
 166                                 len = sizeof(block);
 167                         memset(&block, 0, len);
 168                 }
 169                 if (len == 0)
 170                         break;
 171
 172                 ret = libusb_bulk_transfer(usb->devhdl, 2, (unsigned char*)&block[0], len, &act_len, DEFAULT_TIMEOUT_MS);
 173                 if (ret != 0) {
 174                         sr_dbg("failed to write fpga bitstream block at %#x len %d: %s.", pos, (int)len, libusb_error_name(ret));
 175                         ret = SR_ERR;
 176                         break;
 177                 }
 178                 if (act_len != len) {
 179                         sr_dbg("failed to write fpga bitstream block at %#x len %d: act_len is %d.", pos, (int)len, act_len);
 180                         ret = SR_ERR;
 181                         break;
 182                 }
 183                 pos += len;
 184         }
 185         sr_resource_close(drvc->sr_ctx, &bitstream);
 186         if (ret != 0)
 187                 return ret;
 188         sr_info("FPGA bitstream upload (%" PRIu64 " bytes) done.", bitstream.size);
 189
 190         if ((ret = ctrl_in(sdi, CMD_FPGA_INIT, 0x00, 0, &cmd_resp, sizeof(cmd_resp))) != SR_OK) {
 191                 sr_err("failed to read response after FPGA bitstream upload");
 192                 return ret;
 193         }
 194         if (cmd_resp != 0) {
 195                 sr_err("after fpga bitstream upload command response is 0x%02x, expect 0!", cmd_resp);
 196                 return SR_ERR;
 197         }
 198
 199         g_usleep(30000);
 200
 201         if ((ret = ctrl_out(sdi, CMD_FPGA_ENABLE, 0x01, 0, NULL, 0)) != SR_OK) {
 202                 sr_err("failed enable fpga");
 203                 return ret;
 204         }
 205
 206         g_usleep(40000);
 207         return SR_OK;
 208 }
 209
 210 static int set_threshold_voltage(const struct sr_dev_inst *sdi, float voltage)
 211 {
 212         struct dev_context *devc;
 213         int ret;
 214
 215         devc = sdi->priv;
 216
 217         uint16_t duty_R79,duty_R56;
 218         uint8_t buf[2 * sizeof(uint16_t)];
 219         uint8_t *wrptr;
 220
 221         /* clamp threshold setting within valid range for LA2016 */
 222         if (voltage > 4.0) {
 223                 voltage = 4.0;
 224         }
 225         else if (voltage < -4.0) {
 226                 voltage = -4.0;
 227         }
 228
 229         /*
 230          * The fpga has two programmable pwm outputs which feed a dac that
 231          * is used to adjust input offset. The dac changes the input
 232          * swing around the fixed fpga input threshold.
 233          * The two pwm outputs can be seen on R79 and R56 respectvely.
 234          * Frequency is fixed at 100kHz and duty is varied.
 235          * The R79 pwm uses just three settings.
 236          * The R56 pwm varies with required threshold and its behaviour
 237          * also changes depending on the setting of R79 PWM.
 238          */
 239
 240         /*
 241          * calculate required pwm duty register values from requested threshold voltage
 242          * see last page of schematic (on wiki) for an explanation of these numbers
 243          */
 244         if (voltage >= 2.9) {
 245                 duty_R79 = 0;           /* this pwm is off (0V)*/
 246                 duty_R56 = (uint16_t)(302 * voltage - 363);
 247         }
 248         else if (voltage <= -0.4) {
 249                 duty_R79 = 0x02D7;      /* 72% duty */
 250                 duty_R56 = (uint16_t)(302 * voltage + 1090);
 251         }
 252         else {
 253                 duty_R79 = 0x00f2;      /* 25% duty */
 254                 duty_R56 = (uint16_t)(302 * voltage + 121);
 255         }
 256
 257         /* clamp duty register values at sensible limits */
 258         if (duty_R56 < 10) {
 259                 duty_R56 = 10;
 260         }
 261         else if (duty_R56 > 1100) {
 262                 duty_R56 = 1100;
 263         }
 264
 265         sr_dbg("set threshold voltage %.2fV", voltage);
 266         sr_dbg("duty_R56=0x%04x, duty_R79=0x%04x", duty_R56, duty_R79);
 267
 268         wrptr = buf;
 269         write_u16le_inc(&wrptr, duty_R56);
 270         write_u16le_inc(&wrptr, duty_R79);
 271
 272         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_THRESHOLD, 0, buf, wrptr - buf);
 273         if (ret != SR_OK) {
 274                 sr_err("error setting new threshold voltage of %.2fV", voltage);
 275                 return ret;
 276         }
 277         devc->threshold_voltage = voltage;
 278
 279         return SR_OK;
 280 }
 281
 282 static int enable_pwm(const struct sr_dev_inst *sdi, uint8_t p1, uint8_t p2)
 283 {
 284         struct dev_context *devc;
 285         uint8_t cfg;
 286         int ret;
 287
 288         devc = sdi->priv;
 289         cfg = 0;
 290
 291         if (p1) cfg |= 1 << 0;
 292         if (p2) cfg |= 1 << 1;
 293
 294         sr_dbg("set pwm enable %d %d", p1, p2);
 295         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_PWM_EN, 0, &cfg, sizeof(cfg));
 296         if (ret != SR_OK) {
 297                 sr_err("error setting new pwm enable 0x%02x", cfg);
 298                 return ret;
 299         }
 300         devc->pwm_setting[0].enabled = (p1) ? 1 : 0;
 301         devc->pwm_setting[1].enabled = (p2) ? 1 : 0;
 302
 303         return SR_OK;
 304 }
 305
 306 static int set_pwm(const struct sr_dev_inst *sdi, uint8_t which, float freq, float duty)
 307 {
 308         int CTRL_PWM[] = { REG_PWM1, REG_PWM2 };
 309         struct dev_context *devc;
 310         pwm_setting_dev_t cfg;
 311         pwm_setting_t *setting;
 312         int ret;
 313         uint8_t buf[2 * sizeof(uint32_t)];
 314         uint8_t *wrptr;
 315
 316         devc = sdi->priv;
 317
 318         if (which < 1 || which > 2) {
 319                 sr_err("invalid pwm channel: %d", which);
 320                 return SR_ERR;
 321         }
 322         if (freq > MAX_PWM_FREQ) {
 323                 sr_err("pwm frequency too high: %.1f", freq);
 324                 return SR_ERR;
 325         }
 326         if (duty > 100 || duty < 0) {
 327                 sr_err("invalid pwm percentage: %f", duty);
 328                 return SR_ERR;
 329         }
 330
 331         cfg.period = (uint32_t)(PWM_CLOCK / freq);
 332         cfg.duty = (uint32_t)(0.5f + (cfg.period * duty / 100.));
 333         sr_dbg("set pwm%d period %d, duty %d", which, cfg.period, cfg.duty);
 334
 335         wrptr = buf;
 336         write_u32le_inc(&wrptr, cfg.period);
 337         write_u32le_inc(&wrptr, cfg.duty);
 338         ret = ctrl_out(sdi, CMD_FPGA_SPI, CTRL_PWM[which - 1], 0, buf, wrptr - buf);
 339         if (ret != SR_OK) {
 340                 sr_err("error setting new pwm%d config %d %d", which, cfg.period, cfg.duty);
 341                 return ret;
 342         }
 343         setting = &devc->pwm_setting[which - 1];
 344         setting->freq = freq;
 345         setting->duty = duty;
 346
 347         return SR_OK;
 348 }
 349
 350 static int set_defaults(const struct sr_dev_inst *sdi)
 351 {
 352         struct dev_context *devc;
 353         int ret;
 354
 355         devc = sdi->priv;
 356
 357         devc->capture_ratio = 5; /* percent */
 358         devc->cur_channels = 0xffff;
 359         devc->limit_samples = 5000000;
 360         devc->cur_samplerate = 200000000;
 361
 362         ret = set_threshold_voltage(sdi, devc->threshold_voltage);
 363         if (ret)
 364                 return ret;
 365
 366         ret = enable_pwm(sdi, 0, 0);
 367         if (ret)
 368                 return ret;
 369
 370         ret = set_pwm(sdi, 1, 1e3, 50);
 371         if (ret)
 372                 return ret;
 373
 374         ret = set_pwm(sdi, 2, 100e3, 50);
 375         if (ret)
 376                 return ret;
 377
 378         ret = enable_pwm(sdi, 1, 1);
 379         if (ret)
 380                 return ret;
 381
 382         return SR_OK;
 383 }
 384
 385 static int set_trigger_config(const struct sr_dev_inst *sdi)
 386 {
 387         struct dev_context *devc;
 388         struct sr_trigger *trigger;
 389         trigger_cfg_t cfg;
 390         GSList *stages;
 391         GSList *channel;
 392         struct sr_trigger_stage *stage1;
 393         struct sr_trigger_match *match;
 394         uint16_t ch_mask;
 395         int ret;
 396         uint8_t buf[4 * sizeof(uint32_t)];
 397         uint8_t *wrptr;
 398
 399         devc = sdi->priv;
 400         trigger = sr_session_trigger_get(sdi->session);
 401
 402         memset(&cfg, 0, sizeof(cfg));
 403
 404         cfg.channels = devc->cur_channels;
 405
 406         if (trigger && trigger->stages) {
 407                 stages = trigger->stages;
 408                 stage1 = stages->data;
 409                 if (stages->next) {
 410                         sr_err("Only one trigger stage supported for now.");
 411                         return SR_ERR;
 412                 }
 413                 channel = stage1->matches;
 414                 while (channel) {
 415                         match = channel->data;
 416                         ch_mask = 1 << match->channel->index;
 417
 418                         switch (match->match) {
 419                         case SR_TRIGGER_ZERO:
 420                                 cfg.level |= ch_mask;
 421                                 cfg.high_or_falling &= ~ch_mask;
 422                                 break;
 423                         case SR_TRIGGER_ONE:
 424                                 cfg.level |= ch_mask;
 425                                 cfg.high_or_falling |= ch_mask;
 426                                 break;
 427                         case SR_TRIGGER_RISING:
 428                                 if ((cfg.enabled & ~cfg.level)) {
 429                                         sr_err("Only one trigger signal with falling-/rising-edge allowed.");
 430                                         return SR_ERR;
 431                                 }
 432                                 cfg.level &= ~ch_mask;
 433                                 cfg.high_or_falling &= ~ch_mask;
 434                                 break;
 435                         case SR_TRIGGER_FALLING:
 436                                 if ((cfg.enabled & ~cfg.level)) {
 437                                         sr_err("Only one trigger signal with falling-/rising-edge allowed.");
 438                                         return SR_ERR;
 439                                 }
 440                                 cfg.level &= ~ch_mask;
 441                                 cfg.high_or_falling |= ch_mask;
 442                                 break;
 443                         default:
 444                                 sr_err("Unknown trigger value.");
 445                                 return SR_ERR;
 446                         }
 447                         cfg.enabled |= ch_mask;
 448                         channel = channel->next;
 449                 }
 450         }
 451         sr_dbg("set trigger configuration channels: 0x%04x, "
 452                "trigger-enabled 0x%04x, level-triggered 0x%04x, "
 453                "high/falling 0x%04x", cfg.channels, cfg.enabled, cfg.level,
 454                cfg.high_or_falling);
 455
 456         devc->had_triggers_configured = cfg.enabled != 0;
 457
 458         wrptr = buf;
 459         write_u32le_inc(&wrptr, cfg.channels);
 460         write_u32le_inc(&wrptr, cfg.enabled);
 461         write_u32le_inc(&wrptr, cfg.level);
 462         write_u32le_inc(&wrptr, cfg.high_or_falling);
 463         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_TRIGGER, 16, buf, wrptr - buf);
 464         if (ret != SR_OK) {
 465                 sr_err("error setting trigger config!");
 466                 return ret;
 467         }
 468
 469         return SR_OK;
 470 }
 471
 472 static int set_sample_config(const struct sr_dev_inst *sdi)
 473 {
 474         struct dev_context *devc;
 475         double clock_divisor;
 476         uint64_t total;
 477         int ret;
 478         uint16_t divisor;
 479         uint8_t buf[2 * sizeof(uint32_t) + 48 / 8 + sizeof(uint16_t)];
 480         uint8_t *wrptr;
 481
 482         devc = sdi->priv;
 483         total = 128 * 1024 * 1024;
 484
 485         if (devc->cur_samplerate > MAX_SAMPLE_RATE) {
 486                 sr_err("too high sample rate: %" PRIu64, devc->cur_samplerate);
 487                 return SR_ERR;
 488         }
 489
 490         clock_divisor = MAX_SAMPLE_RATE / (double)devc->cur_samplerate;
 491         if (clock_divisor > 0xffff)
 492                 clock_divisor = 0xffff;
 493         divisor = (uint16_t)(clock_divisor + 0.5);
 494         devc->cur_samplerate = MAX_SAMPLE_RATE / divisor;
 495
 496         if (devc->limit_samples > MAX_SAMPLE_DEPTH) {
 497                 sr_err("too high sample depth: %" PRIu64, devc->limit_samples);
 498                 return SR_ERR;
 499         }
 500
 501         devc->pre_trigger_size = (devc->capture_ratio * devc->limit_samples) / 100;
 502
 503         sr_dbg("set sampling configuration %.0fkHz, %d samples, trigger-pos %d%%",
 504                devc->cur_samplerate / 1e3, (unsigned int)devc->limit_samples, (unsigned int)devc->capture_ratio);
 505
 506         wrptr = buf;
 507         write_u32le_inc(&wrptr, devc->limit_samples);
 508         write_u8_inc(&wrptr, 0);
 509         write_u32le_inc(&wrptr, devc->pre_trigger_size);
 510         write_u32le_inc(&wrptr, ((total * devc->capture_ratio) / 100) & 0xFFFFFF00 );
 511         write_u16le_inc(&wrptr, divisor);
 512         write_u8_inc(&wrptr, 0);
 513
 514         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_SAMPLING, 0, buf, wrptr - buf);
 515         if (ret != SR_OK) {
 516                 sr_err("error setting sample config!");
 517                 return ret;
 518         }
 519
 520         return SR_OK;
 521 }
 522
 523 /* The run state is read from FPGA registers 1[hi-byte] and 0[lo-byte]
 524  * and the bits are interpreted as follows:
 525  *
 526  * register 0:
 527  *      bit0 1= idle
 528  *      bit1 1= writing to sdram
 529  *      bit2 0= waiting_for_trigger 1=been_triggered
 530  *      bit3 0= pretrigger_sampling 1=posttrigger_sampling
 531  *      ...unknown...
 532  * register 1:
 533  *      meaning of bits unknown (but vendor software reads this, so just do the same)
 534  *
 535  * The run state values occur in this order:
 536  * 0x85E2: pre-sampling (for samples before trigger position, capture ratio > 0%)
 537  * 0x85EA: pre-sampling complete, now waiting for trigger (whilst sampling continuously)
 538  * 0x85EE: running
 539  * 0x85ED: idle
 540  */
 541 static uint16_t run_state(const struct sr_dev_inst *sdi)
 542 {
 543         uint16_t state;
 544         static uint16_t previous_state=0;
 545         int ret;
 546
 547         if ((ret = ctrl_in(sdi, CMD_FPGA_SPI, REG_RUN, 0, &state, sizeof(state))) != SR_OK) {
 548                 sr_err("failed to read run state!");
 549                 return ret;
 550         }
 551
 552         /* This function is called about every 50ms.
 553          * To avoid filling the log file with redundant information during long captures,
 554          * just print a log message if status has changed.
 555          */
 556
 557         if(state != previous_state) {
 558                 previous_state = state;
 559                 if((state & 0x0003)==1) {
 560                         sr_dbg("run_state: 0x%04x (%s)", state, "idle");
 561                 }
 562                 else if((state & 0x000f)==2) {
 563                         sr_dbg("run_state: 0x%04x (%s)", state, "pre-trigger sampling");
 564                 }
 565                 else if((state & 0x000f)==0x0a) {
 566                         sr_dbg("run_state: 0x%04x (%s)", state, "sampling, waiting for trigger");
 567                 }
 568                 else if((state & 0x000f)==0x0e) {
 569                         sr_dbg("run_state: 0x%04x (%s)", state, "post-trigger sampling");
 570                 }
 571                 else {
 572                         sr_dbg("run_state: 0x%04x", state);
 573                 }
 574         }
 575
 576         return state;
 577 }
 578
 579 static int set_run_mode(const struct sr_dev_inst *sdi, uint8_t fast_blinking)
 580 {
 581         int ret;
 582
 583         if ((ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_RUN, 0, &fast_blinking, sizeof(fast_blinking))) != SR_OK) {
 584                 sr_err("failed to send set-run-mode command %d", fast_blinking);
 585                 return ret;
 586         }
 587
 588         return SR_OK;
 589 }
 590
 591 static int get_capture_info(const struct sr_dev_inst *sdi)
 592 {
 593         struct dev_context *devc;
 594         int ret;
 595         uint8_t buf[3 * sizeof(uint32_t)];
 596         const uint8_t *rdptr;
 597
 598         devc = sdi->priv;
 599
 600         if ((ret = ctrl_in(sdi, CMD_FPGA_SPI, REG_SAMPLING, 0, buf, sizeof(buf))) != SR_OK) {
 601                 sr_err("failed to read capture info!");
 602                 return ret;
 603         }
 604
 605         rdptr = buf;
 606         devc->info.n_rep_packets = read_u32le_inc(&rdptr);
 607         devc->info.n_rep_packets_before_trigger = read_u32le_inc(&rdptr);
 608         devc->info.write_pos = read_u32le_inc(&rdptr);
 609
 610         sr_dbg("capture info: n_rep_packets: 0x%08x/%d, before_trigger: 0x%08x/%d, write_pos: 0x%08x%d",
 611                devc->info.n_rep_packets, devc->info.n_rep_packets,
 612                devc->info.n_rep_packets_before_trigger, devc->info.n_rep_packets_before_trigger,
 613                devc->info.write_pos, devc->info.write_pos);
 614
 615         if (devc->info.n_rep_packets % 5)
 616                 sr_warn("number of packets is not as expected multiples of 5: %d", devc->info.n_rep_packets);
 617
 618         return SR_OK;
 619 }
 620
 621 SR_PRIV int la2016_upload_firmware(struct sr_context *sr_ctx, libusb_device *dev, uint16_t product_id)
 622 {
 623         char fw_file[1024];
 624         snprintf(fw_file, sizeof(fw_file) - 1, UC_FIRMWARE, product_id);
 625         return ezusb_upload_firmware(sr_ctx, dev, USB_CONFIGURATION, fw_file);
 626 }
 627
 628 SR_PRIV int la2016_setup_acquisition(const struct sr_dev_inst *sdi)
 629 {
 630         struct dev_context *devc;
 631         int ret;
 632         uint8_t cmd;
 633
 634         devc = sdi->priv;
 635
 636         ret = set_threshold_voltage(sdi, devc->threshold_voltage);
 637         if (ret != SR_OK)
 638                 return ret;
 639
 640         cmd = 0;
 641         if ((ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_CAPT_MODE, 0, &cmd, sizeof(cmd))) != SR_OK) {
 642                 sr_err("failed to send stop sampling command");
 643                 return ret;
 644         }
 645
 646         ret = set_trigger_config(sdi);
 647         if (ret != SR_OK)
 648                 return ret;
 649
 650         ret = set_sample_config(sdi);
 651         if (ret != SR_OK)
 652                 return ret;
 653
 654         return SR_OK;
 655 }
 656
 657 SR_PRIV int la2016_start_acquisition(const struct sr_dev_inst *sdi)
 658 {
 659         return set_run_mode(sdi, 3);
 660 }
 661
 662 SR_PRIV int la2016_stop_acquisition(const struct sr_dev_inst *sdi)
 663 {
 664         return set_run_mode(sdi, 0);
 665 }
 666
 667 SR_PRIV int la2016_abort_acquisition(const struct sr_dev_inst *sdi)
 668 {
 669         return la2016_stop_acquisition(sdi);
 670 }
 671
 672 SR_PRIV int la2016_has_triggered(const struct sr_dev_inst *sdi)
 673 {
 674         uint16_t state;
 675
 676         state = run_state(sdi);
 677
 678         return (state & 0x3) == 1;
 679 }
 680
 681 SR_PRIV int la2016_start_retrieval(const struct sr_dev_inst *sdi, libusb_transfer_cb_fn cb)
 682 {
 683         struct dev_context *devc;
 684         struct sr_usb_dev_inst *usb;
 685         int ret;
 686         uint8_t wrbuf[2 * sizeof(uint32_t)];
 687         uint8_t *wrptr;
 688         uint32_t to_read;
 689         uint8_t *buffer;
 690
 691         devc = sdi->priv;
 692         usb = sdi->conn;
 693
 694         if ((ret = get_capture_info(sdi)) != SR_OK)
 695                 return ret;
 696
 697         devc->n_transfer_packets_to_read = devc->info.n_rep_packets / NUM_PACKETS_IN_CHUNK;
 698         devc->n_bytes_to_read = devc->n_transfer_packets_to_read * TRANSFER_PACKET_LENGTH;
 699         devc->read_pos = devc->info.write_pos - devc->n_bytes_to_read;
 700         devc->n_reps_until_trigger = devc->info.n_rep_packets_before_trigger;
 701
 702         sr_dbg("want to read %d tfer-packets starting from pos %d",
 703                devc->n_transfer_packets_to_read, devc->read_pos);
 704
 705         if ((ret = ctrl_out(sdi, CMD_BULK_RESET, 0x00, 0, NULL, 0)) != SR_OK) {
 706                 sr_err("failed to reset bulk state");
 707                 return ret;
 708         }
 709         sr_dbg("will read from 0x%08x, 0x%08x bytes", devc->read_pos, devc->n_bytes_to_read);
 710         wrptr = wrbuf;
 711         write_u32le_inc(&wrptr, devc->read_pos);
 712         write_u32le_inc(&wrptr, devc->n_bytes_to_read);
 713         if ((ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_BULK, 0, wrbuf, wrptr - wrbuf)) != SR_OK) {
 714                 sr_err("failed to send bulk config");
 715                 return ret;
 716         }
 717         if ((ret = ctrl_out(sdi, CMD_BULK_START, 0x00, 0, NULL, 0)) != SR_OK) {
 718                 sr_err("failed to unblock bulk transfers");
 719                 return ret;
 720         }
 721
 722         to_read = devc->n_bytes_to_read;
 723         if (to_read > LA2016_BULK_MAX)
 724                 to_read = LA2016_BULK_MAX;
 725
 726         buffer = g_try_malloc(to_read);
 727         if (!buffer) {
 728                 sr_err("Failed to allocate %d bytes for bulk transfer", to_read);
 729                 return SR_ERR_MALLOC;
 730         }
 731
 732         devc->transfer = libusb_alloc_transfer(0);
 733         libusb_fill_bulk_transfer(
 734                 devc->transfer, usb->devhdl,
 735                 0x86, buffer, to_read,
 736                 cb, (void *)sdi, DEFAULT_TIMEOUT_MS);
 737
 738         if ((ret = libusb_submit_transfer(devc->transfer)) != 0) {
 739                 sr_err("Failed to submit transfer: %s.", libusb_error_name(ret));
 740                 libusb_free_transfer(devc->transfer);
 741                 devc->transfer = NULL;
 742                 g_free(buffer);
 743                 return SR_ERR;
 744         }
 745
 746         return SR_OK;
 747 }
 748
 749 SR_PRIV int la2016_init_device(const struct sr_dev_inst *sdi)
 750 {
 751         uint16_t state;
 752         uint8_t buf[8];
 753         int16_t purchase_date_bcd[2];
 754         uint8_t magic;
 755         int ret;
 756
 757         /* Four bytes of eeprom at 0x20 are purchase year & month in BCD format, with 16bit
 758          * complemented checksum; e.g. 2004DFFB = 2020-April.
 759          * This helps to identify the age of devices if unknown magic numbers occur.
 760          */
 761         if ((ret = ctrl_in(sdi, CMD_EEPROM, 0x20, 0, purchase_date_bcd, sizeof(purchase_date_bcd))) != SR_OK) {
 762                 sr_err("failed to read eeprom purchase_date_bcd");
 763         }
 764         else {
 765                 sr_dbg("purchase date: 20%02hx-%02hx", (purchase_date_bcd[0]) & 0x00ff, (purchase_date_bcd[0] >> 8) & 0x00ff);
 766                 if( purchase_date_bcd[0] != (0x0ffff & ~purchase_date_bcd[1]) ) {
 767                         sr_err("purchase date: checksum failure");
 768                 }
 769         }
 770
 771         /*
 772          * There are four known kingst logic analyser devices which use this same usb vid and pid:
 773          * LA2016, LA1016 and the older revision of each of these. They all use the same hardware
 774          * and the same FX2 mcu firmware but each requires a different fpga bitstream. They are
 775          * differentiated by a 'magic' byte within the 8 bytes of EEPROM from address 0x08.
 776          * For example;
 777          *
 778          * magic=0x08
 779          *  | ~magic=0xf7
 780          *  | |
 781          * 08F7000008F710EF
 782          *          | |
 783          *          | ~magic-backup
 784          *          magic-backup
 785          *
 786          * It seems that only these magic bytes are used, other bytes shown above are 'don't care'.
 787          * Changing the magic byte on newer device to older magic causes OEM software to load
 788          * the older fpga bitstream. The device then functions but has channels out of order.
 789          * It's likely the bitstreams were changed to move input channel pins due to PCB changes.
 790          *
 791          * magic 9 == LA1016a using "kingst-la1016a1-fpga.bitstream" (latest v1.3.0 PCB, perhaps others)
 792          * magic 8 == LA2016a using "kingst-la2016a1-fpga.bitstream" (latest v1.3.0 PCB, perhaps others)
 793          * magic 3 == LA1016 using "kingst-la1016-fpga.bitstream"
 794          * magic 2 == LA2016 using "kingst-la2016-fpga.bitstream"
 795          *
 796          * This was all determined by altering the eeprom contents of an LA2016 and LA1016 and observing
 797          * the vendor software actions, either raising errors or loading specific bitstreams.
 798          *
 799          * Note:
 800          * An LA1016 cannot be converted to an LA2016 by changing the magic number - the bitstream
 801          * will not authenticate with ic U10, which has different security coding for each device type.
 802          */
 803
 804         if ((ret = ctrl_in(sdi, CMD_EEPROM, 0x08, 0, &buf, sizeof(buf))) != SR_OK) {
 805                 sr_err("failed to read eeprom device identifier bytes");
 806                 return ret;
 807         }
 808
 809         magic = 0;
 810         if (buf[0] == (0x0ff & ~buf[1])) {
 811                 /* primary copy of magic passes complement check */
 812                 magic = buf[0];
 813         }
 814         else if (buf[4] == (0x0ff & ~buf[5])) {
 815                 /* backup copy of magic passes complement check */
 816                 sr_dbg("device_type: using backup copy of magic number");
 817                 magic = buf[4];
 818         }
 819
 820         sr_dbg("device_type: magic number is %hhu", magic);
 821
 822         /* select the correct fpga bitstream for this device */
 823         switch (magic) {
 824         case 2:
 825                 ret = upload_fpga_bitstream(sdi, FPGA_FW_LA2016);
 826                 break;
 827         case 8:
 828                 ret = upload_fpga_bitstream(sdi, FPGA_FW_LA2016A);
 829                 break;
 830         default:
 831                 sr_err("device_type: device not supported; magic number indicates this is not an LA2016");
 832                 return SR_ERR;
 833         }
 834
 835         if (ret != SR_OK) {
 836                 sr_err("failed to upload fpga bitstream");
 837                 return ret;
 838         }
 839
 840         state = run_state(sdi);
 841         if (state != 0x85e9) {
 842                 sr_warn("expect run state to be 0x85e9, but it reads 0x%04x", state);
 843         }
 844
 845         if ((ret = ctrl_out(sdi, CMD_BULK_RESET, 0x00, 0, NULL, 0)) != SR_OK) {
 846                 sr_err("failed to send CMD_BULK_RESET");
 847                 return ret;
 848         }
 849
 850         sr_dbg("device should be initialized");
 851
 852         return set_defaults(sdi);
 853 }
 854
 855 SR_PRIV int la2016_deinit_device(const struct sr_dev_inst *sdi)
 856 {
 857         int ret;
 858
 859         if ((ret = ctrl_out(sdi, CMD_FPGA_ENABLE, 0x00, 0, NULL, 0)) != SR_OK) {
 860                 sr_err("failed to send deinit command");
 861                 return ret;
 862         }
 863
 864         return SR_OK;
 865 }