src/hardware/saleae-logic-pro/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2017 Jan Luebbe <jluebbe@lasnet.de>
   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 <config.h>
  21 #include <string.h>
  22 #include "protocol.h"
  23
  24 #define COMMAND_START_CAPTURE   0x01
  25 #define COMMAND_STOP_CAPTURE    0x02
  26 #define COMMAND_READ_EEPROM     0x07
  27 #define COMMAND_WRITE_REG       0x80
  28 #define COMMAND_READ_REG        0x81
  29 #define COMMAND_WRITE_I2C       0x87
  30 #define COMMAND_READ_I2C        0x88
  31 #define COMMAND_WAKE_I2C        0x89
  32 #define COMMAND_READ_FW_VER     0x8b
  33
  34 #define REG_LED_RED             0x0f
  35 #define REG_LED_GREEN           0x10
  36 #define REG_LED_BLUE            0x11
  37
  38 static void iterate_lfsr(const struct sr_dev_inst *sdi)
  39 {
  40         struct dev_context *devc = sdi->priv;
  41         uint32_t lfsr = devc->lfsr;
  42         int i, max;
  43
  44         max = (lfsr & 0x1f) + 34;
  45         for (i = 0; i <= max; i++) {
  46                 lfsr = (lfsr >> 1) |            \
  47                         ((lfsr ^                \
  48                           (lfsr >> 1) ^         \
  49                           (lfsr >> 21) ^        \
  50                           (lfsr >> 31)          \
  51                           ) << 31);
  52         }
  53         sr_dbg("Iterate 0x%08x -> 0x%08x", devc->lfsr, lfsr);
  54         devc->lfsr = lfsr;
  55 }
  56
  57 static void encrypt(const struct sr_dev_inst *sdi, const uint8_t *in, uint8_t *out, uint8_t len)
  58 {
  59         struct dev_context *devc = sdi->priv;
  60         uint32_t lfsr = devc->lfsr;
  61         uint8_t value, mask;
  62         int i;
  63
  64         for (i = 0; i < len; i++) {
  65                 value = in[i];
  66                 mask = lfsr >> (i % 4 * 8);
  67                 if (i == 0)
  68                         value = (value & 0x28) | ((value ^ mask) & ~0x28);
  69                 else
  70                         value = value ^ mask;
  71                 out[i] = value;
  72         }
  73         iterate_lfsr(sdi);
  74 }
  75
  76 static void decrypt(const struct sr_dev_inst *sdi, uint8_t *data, uint8_t len)
  77 {
  78         struct dev_context *devc = sdi->priv;
  79         uint32_t lfsr = devc->lfsr;
  80         int i;
  81
  82         for (i = 0; i < len; i++)
  83                 data[i] ^= (lfsr >> (i % 4 * 8));
  84         iterate_lfsr(sdi);
  85 }
  86
  87 static int transact(const struct sr_dev_inst *sdi,
  88                     const uint8_t *req, uint8_t req_len,
  89                     uint8_t *rsp, uint8_t rsp_len)
  90 {
  91         struct sr_usb_dev_inst *usb = sdi->conn;
  92         uint8_t *req_enc;
  93         uint8_t rsp_dummy[1] = {};
  94         int ret, xfer;
  95
  96         if (req_len < 2 || req_len > 64 || rsp_len > 128 ||
  97             !req || (rsp_len > 0 && !rsp))
  98                 return SR_ERR_ARG;
  99
 100         req_enc = g_malloc(req_len);
 101         encrypt(sdi, req, req_enc, req_len);
 102
 103         ret = libusb_bulk_transfer(usb->devhdl, 1, req_enc, req_len, &xfer, 1000);
 104         if (ret != 0) {
 105                 sr_dbg("Failed to send request 0x%02x: %s.",
 106                        req[1], libusb_error_name(ret));
 107                 return SR_ERR;
 108         }
 109         if (xfer != req_len) {
 110                 sr_dbg("Failed to send request 0x%02x: incorrect length "
 111                        "%d != %d.", req[1], xfer, req_len);
 112                 return SR_ERR;
 113         }
 114
 115         if (req[0] == 0x20) { /* Reseed. */
 116                 return SR_OK;
 117         } else if (rsp_len == 0) {
 118                 rsp = rsp_dummy;
 119                 rsp_len = sizeof(rsp_dummy);
 120         }
 121
 122         ret = libusb_bulk_transfer(usb->devhdl, 0x80 | 1, rsp, rsp_len,
 123                                    &xfer, 1000);
 124         if (ret != 0) {
 125                 sr_dbg("Failed to receive response to request 0x%02x: %s.",
 126                        req[1], libusb_error_name(ret));
 127                 return SR_ERR;
 128         }
 129         if (xfer != rsp_len) {
 130                 sr_dbg("Failed to receive response to request 0x%02x: "
 131                        "incorrect length %d != %d.", req[1], xfer, rsp_len);
 132                 return SR_ERR;
 133         }
 134
 135         decrypt(sdi, rsp, rsp_len);
 136
 137         return SR_OK;
 138 }
 139
 140 static int reseed(const struct sr_dev_inst *sdi)
 141 {
 142         struct dev_context *devc = sdi->priv;
 143         uint8_t req[] = {0x20, 0x24, 0x4b, 0x35, 0x8e};
 144
 145         devc->lfsr = 0;
 146         return transact(sdi, req, sizeof(req), NULL, 0);
 147 }
 148
 149 static int write_regs(const struct sr_dev_inst *sdi, uint8_t (*regs)[2], uint8_t cnt)
 150 {
 151         uint8_t req[64];
 152         int i;
 153
 154         if (cnt < 1 || cnt > 30)
 155                 return SR_ERR_ARG;
 156
 157         req[0] = 0x00;
 158         req[1] = COMMAND_WRITE_REG;
 159         req[2] = cnt;
 160
 161         for (i = 0; i < cnt; i++) {
 162                 req[3 + 2 * i] = regs[i][0];
 163                 req[4 + 2 * i] = regs[i][1];
 164         }
 165
 166         return transact(sdi, req, 3 + (2 * cnt), NULL, 0);
 167 }
 168
 169 static int write_reg(const struct sr_dev_inst *sdi,
 170                      uint8_t address, uint8_t value)
 171 {
 172         uint8_t regs[2] = {address, value};
 173
 174         return write_regs(sdi, &regs, 1);
 175 }
 176
 177 static int get_firmware_version(const struct sr_dev_inst *sdi)
 178 {
 179         uint8_t req[2] = {0x00, COMMAND_READ_FW_VER};
 180         uint8_t rsp[128] = {};
 181         int ret;
 182
 183         ret = transact(sdi, req, sizeof(req), rsp, sizeof(rsp));
 184         if (ret == SR_OK) {
 185                 rsp[63] = 0;
 186                 sr_dbg("fw-version: %s", rsp);
 187         }
 188
 189         return ret;
 190 }
 191
 192 static int read_i2c(const struct sr_dev_inst *sdi, uint8_t *data, uint8_t len)
 193 {
 194         uint8_t req[5];
 195         uint8_t rsp[1 + 128];
 196         int ret;
 197
 198         if (len < 1 || len > 128 || !data)
 199                 return SR_ERR_ARG;
 200
 201         req[0] = 0x00;
 202         req[1] = COMMAND_READ_I2C;
 203         req[2] = 0xc0; /* Fixed address */
 204         req[3] = len;
 205         req[4] = 0; /* Len MSB? */
 206
 207         ret = transact(sdi, req, sizeof(req), rsp, 1 + len);
 208         if (ret != SR_OK)
 209                 return ret;
 210         if (rsp[0] != 0x02) {
 211                 sr_dbg("Failed to do I2C read (0x%02x).", rsp[0]);
 212                 return SR_ERR;
 213         }
 214
 215         memcpy(data, rsp + 1, len);
 216         return SR_OK;
 217 }
 218
 219 static int write_i2c(const struct sr_dev_inst *sdi, const uint8_t *data, uint8_t len)
 220 {
 221         uint8_t req[5 + 128];
 222         uint8_t rsp[1];
 223         int ret;
 224
 225         if (len < 1 || len > 128 || !data)
 226                 return SR_ERR_ARG;
 227
 228         req[0] = 0x00;
 229         req[1] = COMMAND_WRITE_I2C;
 230         req[2] = 0xc0; /* Fixed address */
 231         req[3] = len;
 232         req[4] = 0; /* Len MSB? */
 233         memcpy(req + 5, data, len);
 234
 235         ret = transact(sdi, req, 5 + len, rsp, sizeof(rsp));
 236         if (ret != SR_OK)
 237                 return ret;
 238         if (rsp[0] != 0x02) {
 239                 sr_dbg("Failed to do I2C write (0x%02x).", rsp[0]);
 240                 return SR_ERR;
 241         }
 242
 243         return SR_OK;
 244 }
 245
 246 static int wake_i2c(const struct sr_dev_inst *sdi)
 247 {
 248         uint8_t req[] = {0x00, COMMAND_WAKE_I2C};
 249         uint8_t rsp[1] = {};
 250         uint8_t i2c_rsp[1 + 1 + 2] = {};
 251         int ret;
 252
 253         ret = transact(sdi, req, sizeof(req), rsp, sizeof(rsp));
 254         if (ret != SR_OK)
 255                 return ret;
 256         if (rsp[0] != 0x00) {
 257                 sr_dbg("Failed to do I2C wake trigger (0x%02x).", rsp[0]);
 258                 return SR_ERR;
 259         }
 260
 261         ret = read_i2c(sdi, i2c_rsp, sizeof(i2c_rsp));
 262         if (ret != SR_OK) {
 263                 return ret;
 264         }
 265         if (i2c_rsp[1] != 0x11) {
 266                 sr_dbg("Failed to do I2C wake read (0x%02x).", i2c_rsp[0]);
 267                 return SR_ERR;
 268         }
 269
 270         return SR_OK;
 271 }
 272
 273 static int crypto_random(const struct sr_dev_inst *sdi, uint8_t *data)
 274 {
 275         uint8_t i2c_req[8] = {0x03, 0x07, 0x1b, 0x00, 0x00, 0x00, 0x24, 0xcd};
 276         uint8_t i2c_rsp[1 + 32 + 2] = {};
 277         int ret;
 278
 279         ret = write_i2c(sdi, i2c_req, sizeof(i2c_req));
 280         if (ret != SR_OK)
 281                 return ret;
 282
 283         g_usleep(100000); /* TODO: Poll instead. */
 284
 285         ret = read_i2c(sdi, i2c_rsp, sizeof(i2c_rsp));
 286         if (ret != SR_OK)
 287                 return ret;
 288
 289         if (data)
 290                 memcpy(data, i2c_rsp + 1, 32);
 291
 292         return SR_OK;
 293 }
 294
 295 static int crypto_nonce(const struct sr_dev_inst *sdi, uint8_t *data)
 296 {
 297         uint8_t i2c_req[6 + 20 + 2] = {0x03, 0x1b, 0x16, 0x00, 0x00, 0x00};
 298         uint8_t i2c_rsp[1 + 32 + 2] = {};
 299         int ret;
 300
 301         /* CRC */
 302         i2c_req[26] = 0x7d;
 303         i2c_req[27] = 0xe0;
 304
 305         ret = write_i2c(sdi, i2c_req, sizeof(i2c_req));
 306         if (ret != SR_OK)
 307                 return ret;
 308
 309         g_usleep(100000); /* TODO: Poll instead. */
 310
 311         ret = read_i2c(sdi, i2c_rsp, sizeof(i2c_rsp));
 312         if (ret != SR_OK)
 313                 return ret;
 314
 315         if (data)
 316                 memcpy(data, i2c_rsp + 1, 32);
 317
 318         return SR_OK;
 319 }
 320
 321 static int crypto_sign(const struct sr_dev_inst *sdi, uint8_t *data, uint8_t *crc)
 322 {
 323         uint8_t i2c_req[8] = {0x03, 0x07, 0x41, 0x80, 0x00, 0x00, 0x28, 0x05};
 324         uint8_t i2c_rsp[1 + 64 + 2] = {};
 325         int ret;
 326
 327         ret = write_i2c(sdi, i2c_req, sizeof(i2c_req));
 328         if (ret != SR_OK)
 329                 return ret;
 330
 331         g_usleep(100000); /* TODO: Poll instead. */
 332
 333         ret = read_i2c(sdi, i2c_rsp, sizeof(i2c_rsp));
 334         if (ret != SR_OK)
 335                 return ret;
 336
 337         memcpy(data, i2c_rsp + 1, 64);
 338         memcpy(crc, i2c_rsp + 1 + 64, 2);
 339
 340         return SR_OK;
 341 }
 342
 343 static int authenticate(const struct sr_dev_inst *sdi)
 344 {
 345         struct dev_context *devc = sdi->priv;
 346         uint8_t random[32] = {};
 347         uint8_t nonce[32] = {};
 348         uint8_t sig[64] = {};
 349         uint8_t sig_crc[64] = {};
 350         uint32_t lfsr;
 351         int i, ret;
 352
 353         ret = wake_i2c(sdi);
 354         if (ret != SR_OK)
 355                 return ret;
 356
 357         ret = crypto_random(sdi, random);
 358         if (ret != SR_OK)
 359                 return ret;
 360         sr_dbg("random: 0x%02x 0x%02x 0x%02x 0x%02x", random[0], random[1], random[2], random[3]);
 361
 362         ret = crypto_nonce(sdi, nonce);
 363         if (ret != SR_OK)
 364                 return ret;
 365         sr_dbg("nonce: 0x%02x 0x%02x 0x%02x 0x%02x", nonce[0], nonce[1], nonce[2], nonce[3]);
 366
 367         ret = crypto_nonce(sdi, nonce);
 368         if (ret != SR_OK)
 369                 return ret;
 370         sr_dbg("nonce: 0x%02x 0x%02x 0x%02x 0x%02x", nonce[0], nonce[1], nonce[2], nonce[3]);
 371
 372         ret = crypto_sign(sdi, sig, sig_crc);
 373         if (ret != SR_OK)
 374                 return ret;
 375         sr_dbg("sig: 0x%02x 0x%02x 0x%02x 0x%02x", sig[0], sig[1], sig[2], sig[3]);
 376         sr_dbg("sig crc: 0x%02x 0x%02x", sig_crc[0], sig_crc[1]);
 377
 378         lfsr = 0;
 379         for (i = 0; i < 28; i++)
 380                 lfsr ^= nonce[i] << (8 * (i % 4));
 381         lfsr ^= sig_crc[0] | sig_crc[1] << 8;
 382
 383         sr_dbg("Authenticate 0x%08x -> 0x%08x", devc->lfsr, lfsr);
 384         devc->lfsr = lfsr;
 385
 386         return SR_OK;
 387 }
 388
 389 #if 0
 390 static int set_led(const struct sr_dev_inst *sdi, uint8_t r, uint8_t g, uint8_t b)
 391 {
 392         uint8_t regs[][2] = {
 393                 {REG_LED_RED, r},
 394                 {REG_LED_GREEN, g},
 395                 {REG_LED_BLUE, b},
 396         };
 397
 398         authenticate(sdi);
 399
 400         return write_regs(sdi, regs, G_N_ELEMENTS(regs));
 401 }
 402 #endif
 403
 404 static int configure_channels(const struct sr_dev_inst *sdi)
 405 {
 406         struct dev_context *devc = sdi->priv;
 407         const struct sr_channel *c;
 408         const GSList *l;
 409         uint16_t mask;
 410
 411         devc->dig_channel_cnt = 0;
 412         devc->dig_channel_mask = 0;
 413         for (l = sdi->channels; l; l = l->next) {
 414                 c = l->data;
 415                 if (!c->enabled)
 416                         continue;
 417
 418                 mask = 1 << c->index;
 419                 devc->dig_channel_masks[devc->dig_channel_cnt++] = mask;
 420                 devc->dig_channel_mask |= mask;
 421
 422         }
 423         sr_dbg("%d channels enabled (0x%04x)",
 424                devc->dig_channel_cnt, devc->dig_channel_mask);
 425
 426         return SR_OK;
 427 }
 428
 429 SR_PRIV int saleae_logic_pro_init(const struct sr_dev_inst *sdi)
 430 {
 431         reseed(sdi);
 432         get_firmware_version(sdi);
 433         /* Setting the LED doesn't work yet. */
 434         /* set_led(sdi, 0x00, 0x00, 0xff); */
 435
 436         return SR_OK;
 437 }
 438
 439 SR_PRIV int saleae_logic_pro_prepare(const struct sr_dev_inst *sdi)
 440 {
 441         struct dev_context *devc = sdi->priv;
 442         uint8_t regs_unknown[][2] = {
 443                 {0x03, 0x0f},
 444                 {0x04, 0x00},
 445                 {0x05, 0x00},
 446         };
 447         uint8_t regs_config[][2] = {
 448                 {0x00, 0x00},
 449                 {0x08, 0x00}, /* Analog channel mask (LSB) */
 450                 {0x09, 0x00}, /* Analog channel mask (MSB) */
 451                 {0x06, 0x01}, /* Digital channel mask (LSB) */
 452                 {0x07, 0x00}, /* Digital channel mask (MSB) */
 453                 {0x0a, 0x00}, /* Analog sample rate? */
 454                 {0x0b, 0x64}, /* Digital sample rate? */
 455                 {0x0c, 0x00},
 456                 {0x0d, 0x00}, /* Analog mux rate? */
 457                 {0x0e, 0x01}, /* Digital mux rate? */
 458                 {0x12, 0x04},
 459                 {0x13, 0x00},
 460                 {0x14, 0xff}, /* Pre-divider? */
 461         };
 462         uint8_t start_req[] = {0x00, 0x01};
 463         uint8_t start_rsp[2] = {};
 464
 465         configure_channels(sdi);
 466
 467         /* Digital channel mask and muxing */
 468         regs_config[3][1] = devc->dig_channel_mask;
 469         regs_config[4][1] = devc->dig_channel_mask >> 8;
 470         regs_config[9][1] = devc->dig_channel_cnt;
 471
 472         /* Samplerate */
 473         switch (devc->dig_samplerate) {
 474         case SR_MHZ(1):
 475                 regs_config[6][1] = 0x64;
 476                 break;
 477         case SR_MHZ(2):
 478                 regs_config[6][1] = 0x32;
 479                 break;
 480         case SR_KHZ(2500):
 481                 regs_config[6][1] = 0x28;
 482                 break;
 483         case SR_MHZ(10):
 484                 regs_config[6][1] = 0x0a;
 485                 break;
 486         case SR_MHZ(25):
 487                 regs_config[6][1] = 0x04;
 488                 regs_config[12][1] = 0x80;
 489                 break;
 490         case SR_MHZ(50):
 491                 regs_config[6][1] = 0x02;
 492                 regs_config[12][1] = 0x40;
 493                 break;
 494         default:
 495                 return SR_ERR_ARG;
 496         }
 497
 498         authenticate(sdi);
 499
 500         write_reg(sdi, 0x15, 0x03);
 501         write_regs(sdi, regs_unknown, G_N_ELEMENTS(regs_unknown));
 502         write_regs(sdi, regs_config, G_N_ELEMENTS(regs_config));
 503
 504         transact(sdi, start_req, sizeof(start_req), start_rsp, sizeof(start_rsp));
 505
 506         return SR_OK;
 507 }
 508
 509 SR_PRIV int saleae_logic_pro_start(const struct sr_dev_inst *sdi)
 510 {
 511         struct dev_context *devc = sdi->priv;
 512
 513         devc->conv_size = 0;
 514         devc->batch_index = 0;
 515
 516         write_reg(sdi, 0x00, 0x01);
 517
 518         return SR_OK;
 519 }
 520
 521 SR_PRIV int saleae_logic_pro_stop(const struct sr_dev_inst *sdi)
 522 {
 523         uint8_t stop_req[] = {0x00, 0x02};
 524         uint8_t stop_rsp[2] = {};
 525
 526         write_reg(sdi, 0x00, 0x00);
 527         transact(sdi, stop_req, sizeof(stop_req), stop_rsp, sizeof(stop_rsp));
 528
 529         return SR_OK;
 530 }
 531
 532 static void saleae_logic_pro_send_data(const struct sr_dev_inst *sdi,
 533                                       void *data, size_t length, size_t unitsize)
 534 {
 535         const struct sr_datafeed_logic logic = {
 536                 .length = length,
 537                 .unitsize = unitsize,
 538                 .data = data
 539         };
 540
 541         const struct sr_datafeed_packet packet = {
 542                 .type = SR_DF_LOGIC,
 543                 .payload = &logic
 544         };
 545
 546         sr_session_send(sdi, &packet);
 547 }
 548
 549 /*
 550  * One batch from the device consists of 32 samples per active digital channel.
 551  * This stream of batches is packed into USB packets with 16384 bytes each.
 552  */
 553 static void saleae_logic_pro_convert_data(const struct sr_dev_inst *sdi,
 554                                          const uint32_t *src, size_t srccnt)
 555 {
 556         struct dev_context *devc = sdi->priv;
 557         uint8_t *dst = devc->conv_buffer;
 558         uint32_t samples;
 559         uint16_t channel_mask;
 560         unsigned int sample_index, batch_index;
 561         uint16_t *dst_batch;
 562
 563         /* Copy partial batch to the beginning. */
 564         memcpy(dst, dst + devc->conv_size, CONV_BATCH_SIZE);
 565         /* Reset converted size. */
 566         devc->conv_size = 0;
 567
 568         batch_index = devc->batch_index;
 569         while (srccnt--) {
 570                 samples = *src++;
 571                 dst_batch = (uint16_t*)dst;
 572
 573                 /* First index of the batch. */
 574                 if (batch_index == 0)
 575                         memset(dst, 0, CONV_BATCH_SIZE);
 576
 577                 /* Convert one channel. */
 578                 channel_mask = devc->dig_channel_masks[batch_index];
 579                 for (sample_index = 0; sample_index <= 31; sample_index++)
 580                         if ((samples >> (31 - sample_index)) & 1)
 581                                 dst_batch[sample_index] |= channel_mask;
 582
 583                 /* Last index of the batch. */
 584                 if (++batch_index == devc->dig_channel_cnt) {
 585                         devc->conv_size += CONV_BATCH_SIZE;
 586                         batch_index = 0;
 587                         dst += CONV_BATCH_SIZE;
 588                 }
 589         }
 590         devc->batch_index = batch_index;
 591 }
 592
 593 SR_PRIV void LIBUSB_CALL saleae_logic_pro_receive_data(struct libusb_transfer *transfer)
 594 {
 595         const struct sr_dev_inst *sdi = transfer->user_data;
 596         struct dev_context *devc = sdi->priv;
 597         int ret;
 598
 599         switch (transfer->status) {
 600         case LIBUSB_TRANSFER_NO_DEVICE:
 601                 sr_dbg("FIXME no device");
 602                 return;
 603         case LIBUSB_TRANSFER_COMPLETED:
 604         case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though. */
 605                 break;
 606         default:
 607                 /* FIXME */
 608                 return;
 609         }
 610
 611         saleae_logic_pro_convert_data(sdi, (uint32_t*)transfer->buffer, 16 * 1024 / 4);
 612         saleae_logic_pro_send_data(sdi, devc->conv_buffer, devc->conv_size, 2);
 613
 614         if ((ret = libusb_submit_transfer(transfer)) != LIBUSB_SUCCESS)
 615                 sr_dbg("FIXME resubmit failed");
 616 }