src/pld/lattice.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 /***************************************************************************
   4  *   Copyright (C) 2022 by Daniel Anselmi                                  *
   5  *   danselmi@gmx.ch                                                       *
   6  ***************************************************************************/
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif
  11
  12 #include "lattice.h"
  13 #include <jtag/jtag.h>
  14 #include "pld.h"
  15 #include "lattice_bit.h"
  16 #include "ecp2_3.h"
  17 #include "ecp5.h"
  18 #include "certus.h"
  19
  20 #define PRELOAD              0x1C
  21 #define USER1                0x32
  22 #define USER2                0x38
  23
  24
  25 struct lattice_devices_elem {
  26         uint32_t id;
  27         size_t preload_length;
  28         enum lattice_family_e family;
  29 };
  30
  31 static const struct lattice_devices_elem lattice_devices[] = {
  32         {0x01270043,  654, LATTICE_ECP2 /* ecp2-6e */},
  33         {0x01271043,  643, LATTICE_ECP2 /* ecp2-12e */},
  34         {0x01272043,  827, LATTICE_ECP2 /* ecp2-20e */},
  35         {0x01274043, 1011, LATTICE_ECP2 /* ecp2-35e */},
  36         {0x01273043, 1219, LATTICE_ECP2 /* ecp2-50e */},
  37         {0x01275043,  654, LATTICE_ECP2 /* ecp2-70e */},
  38         {0x01279043,  680, LATTICE_ECP2 /* ecp2m20e */},
  39         {0x0127A043,  936, LATTICE_ECP2 /* ecp2m35e */},
  40         {0x0127B043, 1056, LATTICE_ECP2 /* ecp2m50e */},
  41         {0x0127C043, 1039, LATTICE_ECP2 /* ecp2m70e */},
  42         {0x0127D043, 1311, LATTICE_ECP2 /* ecp2m100e */},
  43         {0x01010043,  467, LATTICE_ECP3 /* ecp3 lae3-17ea & lfe3-17ea*/},
  44         {0x01012043,  675, LATTICE_ECP3 /* ecp3 lae3-35ea & lfe3-35ea*/},
  45         {0x01014043, 1077, LATTICE_ECP3 /* ecp3 lfe3-70ea & lfe3-70e & lfe3-95ea && lfe3-95e*/},
  46         {0x01015043, 1326, LATTICE_ECP3 /* ecp3 lfe3-150e*/},
  47         {0x21111043,  409, LATTICE_ECP5 /* "LAE5U-12F & LFE5U-12F" */},
  48         {0x41111043,  409, LATTICE_ECP5 /* "LFE5U-25F" */},
  49         {0x41112043,  510, LATTICE_ECP5 /* "LFE5U-45F" */},
  50         {0x41113043,  750, LATTICE_ECP5 /* "LFE5U-85F" */},
  51         {0x81111043,  409, LATTICE_ECP5 /* "LFE5UM5G-25F" */},
  52         {0x81112043,  510, LATTICE_ECP5 /* "LFE5UM5G-45F" */},
  53         {0x81113043,  750, LATTICE_ECP5 /* "LFE5UM5G-85F" */},
  54         {0x01111043,  409, LATTICE_ECP5 /* "LAE5UM-25F" */},
  55         {0x01112043,  510, LATTICE_ECP5 /* "LAE5UM-45F" */},
  56         {0x01113043,  750, LATTICE_ECP5 /* "LAE5UM-85F" */},
  57         {0x310f0043,  362, LATTICE_CERTUS /* LFD2NX-17 */},
  58         {0x310f1043,  362, LATTICE_CERTUS /* LFD2NX-40 */},
  59         {0x010f4043,  362, LATTICE_CERTUS /* LFCPNX-100 */},
  60 };
  61
  62 int lattice_set_instr(struct jtag_tap *tap, uint8_t new_instr, tap_state_t endstate)
  63 {
  64         struct scan_field field;
  65         field.num_bits = tap->ir_length;
  66         void *t = calloc(DIV_ROUND_UP(field.num_bits, 8), 1);
  67         if (!t) {
  68                 LOG_ERROR("Out of memory");
  69                 return ERROR_FAIL;
  70         }
  71         field.out_value = t;
  72         buf_set_u32(t, 0, field.num_bits, new_instr);
  73         field.in_value = NULL;
  74         jtag_add_ir_scan(tap, &field, endstate);
  75         free(t);
  76         return ERROR_OK;
  77 }
  78
  79 static int lattice_check_device_family(struct lattice_pld_device *lattice_device)
  80 {
  81         if (lattice_device->family != LATTICE_UNKNOWN && lattice_device->preload_length != 0)
  82                 return ERROR_OK;
  83
  84         if (!lattice_device->tap || !lattice_device->tap->has_idcode)
  85                 return ERROR_FAIL;
  86
  87         for (size_t i = 0; i < ARRAY_SIZE(lattice_devices); ++i) {
  88                 if (lattice_devices[i].id == lattice_device->tap->idcode) {
  89                         if (lattice_device->family == LATTICE_UNKNOWN)
  90                                 lattice_device->family = lattice_devices[i].family;
  91                         if (lattice_device->preload_length == 0)
  92                                 lattice_device->preload_length = lattice_devices[i].preload_length;
  93                         return ERROR_OK;
  94                 }
  95         }
  96         LOG_ERROR("Unknown id! Specify family and preload-length manually.");
  97         return ERROR_FAIL;
  98 }
  99
 100 int lattice_read_u32_register(struct jtag_tap *tap, uint8_t cmd, uint32_t *in_val,
 101                                                         uint32_t out_val, bool do_idle)
 102 {
 103         struct scan_field field;
 104         uint8_t buffer[4];
 105
 106         int retval = lattice_set_instr(tap, cmd, TAP_IDLE);
 107         if (retval != ERROR_OK)
 108                 return retval;
 109         if (do_idle) {
 110                 jtag_add_runtest(2, TAP_IDLE);
 111                 jtag_add_sleep(1000);
 112         }
 113
 114         h_u32_to_le(buffer, out_val);
 115         field.num_bits = 32;
 116         field.out_value = buffer;
 117         field.in_value = buffer;
 118         jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);
 119         retval = jtag_execute_queue();
 120         if (retval == ERROR_OK)
 121                 *in_val = le_to_h_u32(buffer);
 122
 123         return retval;
 124 }
 125
 126 int lattice_read_u64_register(struct jtag_tap *tap, uint8_t cmd, uint64_t *in_val,
 127                                                         uint64_t out_val)
 128 {
 129         struct scan_field field;
 130         uint8_t buffer[8];
 131
 132         int retval = lattice_set_instr(tap, cmd, TAP_IDLE);
 133         if (retval != ERROR_OK)
 134                 return retval;
 135         h_u64_to_le(buffer, out_val);
 136         field.num_bits = 64;
 137         field.out_value = buffer;
 138         field.in_value = buffer;
 139         jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);
 140         retval = jtag_execute_queue();
 141         if (retval == ERROR_OK)
 142                 *in_val = le_to_h_u64(buffer);
 143
 144         return retval;
 145 }
 146
 147 int lattice_preload(struct lattice_pld_device *lattice_device)
 148 {
 149         struct scan_field field;
 150         size_t sz_bytes = DIV_ROUND_UP(lattice_device->preload_length, 8);
 151
 152         int retval = lattice_set_instr(lattice_device->tap, PRELOAD, TAP_IDLE);
 153         if (retval != ERROR_OK)
 154                 return retval;
 155         uint8_t *buffer = malloc(sz_bytes);
 156         if (!buffer) {
 157                 LOG_ERROR("Out of memory");
 158                 return ERROR_FAIL;
 159         }
 160         memset(buffer, 0xff, sz_bytes);
 161
 162         field.num_bits = lattice_device->preload_length;
 163         field.out_value = buffer;
 164         field.in_value = NULL;
 165         jtag_add_dr_scan(lattice_device->tap, 1, &field, TAP_IDLE);
 166         retval = jtag_execute_queue();
 167         free(buffer);
 168         return retval;
 169 }
 170
 171 static int lattice_read_usercode(struct lattice_pld_device *lattice_device, uint32_t *usercode, uint32_t out)
 172 {
 173         struct jtag_tap *tap = lattice_device->tap;
 174         if (!tap)
 175                 return ERROR_FAIL;
 176
 177         if (lattice_device->family == LATTICE_ECP2 || lattice_device->family == LATTICE_ECP3)
 178                 return lattice_ecp2_3_read_usercode(tap, usercode, out);
 179         else if (lattice_device->family == LATTICE_ECP5)
 180                 return lattice_ecp5_read_usercode(tap, usercode, out);
 181         else if (lattice_device->family == LATTICE_CERTUS)
 182                 return lattice_certus_read_usercode(tap, usercode, out);
 183
 184         return ERROR_FAIL;
 185 }
 186
 187 int lattice_verify_usercode(struct lattice_pld_device *lattice_device, uint32_t out,
 188                                                 uint32_t expected, uint32_t mask)
 189 {
 190         uint32_t usercode;
 191
 192         int retval = lattice_read_usercode(lattice_device, &usercode, out);
 193         if (retval != ERROR_OK)
 194                 return retval;
 195
 196         if ((usercode & mask) != expected) {
 197                 LOG_ERROR("verifying user code register failed got: 0x%08" PRIx32 " expected: 0x%08" PRIx32,
 198                         usercode & mask, expected);
 199                 return ERROR_FAIL;
 200         }
 201         return ERROR_OK;
 202 }
 203
 204 static int lattice_write_usercode(struct lattice_pld_device *lattice_device, uint32_t usercode)
 205 {
 206         if (lattice_device->family == LATTICE_ECP2 || lattice_device->family == LATTICE_ECP3)
 207                 return lattice_ecp2_3_write_usercode(lattice_device, usercode);
 208         else if (lattice_device->family == LATTICE_ECP5)
 209                 return lattice_ecp5_write_usercode(lattice_device, usercode);
 210         else if (lattice_device->family == LATTICE_CERTUS)
 211                 return lattice_certus_write_usercode(lattice_device, usercode);
 212
 213         return ERROR_FAIL;
 214 }
 215
 216 static int lattice_read_status_u32(struct lattice_pld_device *lattice_device, uint32_t *status,
 217                                                                 uint32_t out, bool do_idle)
 218 {
 219         if (!lattice_device->tap)
 220                 return ERROR_FAIL;
 221
 222         if (lattice_device->family == LATTICE_ECP2 || lattice_device->family == LATTICE_ECP3)
 223                 return lattice_ecp2_3_read_status(lattice_device->tap, status, out, do_idle);
 224         else if (lattice_device->family == LATTICE_ECP5)
 225                 return lattice_ecp5_read_status(lattice_device->tap, status, out, do_idle);
 226
 227         return ERROR_FAIL;
 228 }
 229 static int lattice_read_status_u64(struct lattice_pld_device *lattice_device, uint64_t *status,
 230                                                                 uint64_t out)
 231 {
 232         if (!lattice_device->tap)
 233                 return ERROR_FAIL;
 234
 235         if (lattice_device->family == LATTICE_CERTUS)
 236                 return lattice_certus_read_status(lattice_device->tap, status, out);
 237
 238         return ERROR_FAIL;
 239 }
 240
 241 int lattice_verify_status_register_u32(struct lattice_pld_device *lattice_device, uint32_t out,
 242                                                 uint32_t expected, uint32_t mask, bool do_idle)
 243 {
 244         uint32_t status;
 245         int retval = lattice_read_status_u32(lattice_device, &status, out, do_idle);
 246         if (retval != ERROR_OK)
 247                 return retval;
 248
 249         if ((status & mask) != expected) {
 250                 LOG_ERROR("verifying status register failed got: 0x%08" PRIx32 " expected: 0x%08" PRIx32,
 251                         status & mask, expected);
 252                 return ERROR_FAIL;
 253         }
 254         return ERROR_OK;
 255 }
 256
 257 int lattice_verify_status_register_u64(struct lattice_pld_device *lattice_device, uint64_t out,
 258                                                 uint64_t expected, uint64_t mask)
 259 {
 260         uint64_t status;
 261         int retval = lattice_read_status_u64(lattice_device, &status, out);
 262         if (retval != ERROR_OK)
 263                 return retval;
 264
 265         if ((status & mask) != expected) {
 266                 LOG_ERROR("verifying status register failed got: 0x%08" PRIx64 " expected: 0x%08" PRIx64,
 267                         status & mask, expected);
 268                 return ERROR_FAIL;
 269         }
 270         return ERROR_OK;
 271 }
 272
 273 static int lattice_load_command(struct pld_device *pld_device, const char *filename)
 274 {
 275         if (!pld_device)
 276                 return ERROR_FAIL;
 277
 278         struct lattice_pld_device *lattice_device = pld_device->driver_priv;
 279         if (!lattice_device || !lattice_device->tap)
 280                 return ERROR_FAIL;
 281         struct jtag_tap *tap = lattice_device->tap;
 282
 283         if (!tap || !tap->has_idcode)
 284                 return ERROR_FAIL;
 285
 286         int retval = lattice_check_device_family(lattice_device);
 287         if (retval != ERROR_OK)
 288                 return retval;
 289
 290         struct lattice_bit_file bit_file;
 291         retval = lattice_read_file(&bit_file, filename, lattice_device->family);
 292         if (retval != ERROR_OK)
 293                 return retval;
 294
 295         uint32_t id = tap->idcode;
 296         retval = ERROR_FAIL;
 297         switch (lattice_device->family) {
 298         case LATTICE_ECP2:
 299                 retval = lattice_ecp2_load(lattice_device, &bit_file);
 300                 break;
 301         case LATTICE_ECP3:
 302                 retval = lattice_ecp3_load(lattice_device, &bit_file);
 303                 break;
 304         case LATTICE_ECP5:
 305         case LATTICE_CERTUS:
 306                 if (bit_file.has_id && id != bit_file.idcode)
 307                         LOG_WARNING("Id on device (0x%8.8" PRIx32 ") and id in bit-stream (0x%8.8" PRIx32 ") don't match.",
 308                                 id, bit_file.idcode);
 309                 if (lattice_device->family == LATTICE_ECP5)
 310                         retval = lattice_ecp5_load(lattice_device, &bit_file);
 311                 else
 312                         retval = lattice_certus_load(lattice_device, &bit_file);
 313                 break;
 314         default:
 315                 LOG_ERROR("loading unknown device family");
 316                 break;
 317         }
 318         free(bit_file.raw_bit.data);
 319         return retval;
 320 }
 321
 322 static int lattice_get_ipdbg_hub(int user_num, struct pld_device *pld_device, struct pld_ipdbg_hub *hub)
 323 {
 324         if (!pld_device)
 325                 return ERROR_FAIL;
 326
 327         struct lattice_pld_device *pld_device_info = pld_device->driver_priv;
 328
 329         if (!pld_device_info || !pld_device_info->tap)
 330                 return ERROR_FAIL;
 331
 332         hub->tap = pld_device_info->tap;
 333
 334         if (user_num == 1) {
 335                 hub->user_ir_code = USER1;
 336         } else if (user_num == 2) {
 337                 hub->user_ir_code = USER2;
 338         } else {
 339                 LOG_ERROR("lattice devices only have user register 1 & 2");
 340                 return ERROR_FAIL;
 341         }
 342         return ERROR_OK;
 343 }
 344
 345 static int lattice_connect_spi_to_jtag(struct pld_device *pld_device)
 346 {
 347         if (!pld_device)
 348                 return ERROR_FAIL;
 349
 350         struct lattice_pld_device *pld_device_info = pld_device->driver_priv;
 351
 352         int retval = lattice_check_device_family(pld_device_info);
 353         if (retval != ERROR_OK)
 354                 return retval;
 355
 356         if (pld_device_info->family == LATTICE_ECP2 || pld_device_info->family == LATTICE_ECP3)
 357                 return lattice_ecp2_3_connect_spi_to_jtag(pld_device_info);
 358         else if (pld_device_info->family == LATTICE_ECP5)
 359                 return lattice_ecp5_connect_spi_to_jtag(pld_device_info);
 360         else if (pld_device_info->family == LATTICE_CERTUS)
 361                 return lattice_certus_connect_spi_to_jtag(pld_device_info);
 362
 363         return ERROR_FAIL;
 364 }
 365
 366 static int lattice_disconnect_spi_from_jtag(struct pld_device *pld_device)
 367 {
 368         if (!pld_device)
 369                 return ERROR_FAIL;
 370
 371         struct lattice_pld_device *pld_device_info = pld_device->driver_priv;
 372
 373         int retval = lattice_check_device_family(pld_device_info);
 374         if (retval != ERROR_OK)
 375                 return retval;
 376
 377         if (pld_device_info->family == LATTICE_ECP2 || pld_device_info->family == LATTICE_ECP3)
 378                 return lattice_ecp2_3_disconnect_spi_from_jtag(pld_device_info);
 379         else if (pld_device_info->family == LATTICE_ECP5)
 380                 return lattice_ecp5_disconnect_spi_from_jtag(pld_device_info);
 381         else if (pld_device_info->family == LATTICE_CERTUS)
 382                 return lattice_certus_disconnect_spi_from_jtag(pld_device_info);
 383
 384         return ERROR_FAIL;
 385 }
 386
 387 static int lattice_get_stuff_bits(struct pld_device *pld_device, unsigned int *facing_read_bits,
 388                 unsigned int *trailing_write_bits)
 389 {
 390         if (!pld_device)
 391                 return ERROR_FAIL;
 392
 393         struct lattice_pld_device *pld_device_info = pld_device->driver_priv;
 394
 395         int retval = lattice_check_device_family(pld_device_info);
 396         if (retval != ERROR_OK)
 397                 return retval;
 398
 399         if (pld_device_info->family == LATTICE_ECP2 || pld_device_info->family == LATTICE_ECP3)
 400                 return lattice_ecp2_3_get_facing_read_bits(pld_device_info, facing_read_bits);
 401         else if (pld_device_info->family == LATTICE_ECP5)
 402                 return lattice_ecp5_get_facing_read_bits(pld_device_info, facing_read_bits);
 403         else if (pld_device_info->family == LATTICE_CERTUS)
 404                 return lattice_certus_get_facing_read_bits(pld_device_info, facing_read_bits);
 405
 406         return ERROR_FAIL;
 407 }
 408
 409 static int lattice_has_jtagspi_instruction(struct pld_device *device, bool *has_instruction)
 410 {
 411         *has_instruction = true;
 412         return ERROR_OK;
 413 }
 414
 415 PLD_CREATE_COMMAND_HANDLER(lattice_pld_create_command)
 416 {
 417         if (CMD_ARGC != 4 && CMD_ARGC != 6)
 418                 return ERROR_COMMAND_SYNTAX_ERROR;
 419
 420         if (strcmp(CMD_ARGV[2], "-chain-position") != 0)
 421                 return ERROR_COMMAND_SYNTAX_ERROR;
 422
 423         struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[3]);
 424         if (!tap) {
 425                 command_print(CMD, "Tap: %s does not exist", CMD_ARGV[3]);
 426                 return ERROR_FAIL;
 427         }
 428
 429         /* id is not known yet -> postpone lattice_check_device_family() */
 430         enum lattice_family_e family = LATTICE_UNKNOWN;
 431         if (CMD_ARGC == 6) {
 432                 if (strcmp(CMD_ARGV[4], "-family") != 0)
 433                         return ERROR_COMMAND_SYNTAX_ERROR;
 434
 435                 if (strcasecmp(CMD_ARGV[5], "ecp2") == 0) {
 436                         family = LATTICE_ECP2;
 437                 } else if (strcasecmp(CMD_ARGV[5], "ecp3") == 0) {
 438                         family = LATTICE_ECP3;
 439                 } else if (strcasecmp(CMD_ARGV[5], "ecp5") == 0) {
 440                         family = LATTICE_ECP5;
 441                 } else if (strcasecmp(CMD_ARGV[5], "certus") == 0) {
 442                         family = LATTICE_CERTUS;
 443                 } else {
 444                         command_print(CMD, "unknown family");
 445                         return ERROR_FAIL;
 446                 }
 447         }
 448
 449         struct lattice_pld_device *lattice_device = malloc(sizeof(struct lattice_pld_device));
 450         if (!lattice_device) {
 451                 LOG_ERROR("Out of memory");
 452                 return ERROR_FAIL;
 453         }
 454
 455         lattice_device->tap = tap;
 456         lattice_device->family = family;
 457         lattice_device->preload_length = 0;
 458
 459         pld->driver_priv = lattice_device;
 460
 461         return ERROR_OK;
 462 }
 463
 464 COMMAND_HANDLER(lattice_read_usercode_register_command_handler)
 465 {
 466         uint32_t usercode;
 467
 468         if (CMD_ARGC != 1)
 469                 return ERROR_COMMAND_SYNTAX_ERROR;
 470
 471         struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 472         if (!device) {
 473                 command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 474                 return ERROR_FAIL;
 475         }
 476
 477         struct lattice_pld_device *lattice_device = device->driver_priv;
 478         if (!lattice_device)
 479                 return ERROR_FAIL;
 480
 481         int retval = lattice_check_device_family(lattice_device);
 482         if (retval != ERROR_OK)
 483                 return retval;
 484
 485         retval = lattice_read_usercode(lattice_device, &usercode, 0x0);
 486         if (retval == ERROR_OK)
 487                 command_print(CMD, "0x%8.8" PRIx32, usercode);
 488
 489         return retval;
 490 }
 491
 492 COMMAND_HANDLER(lattice_set_preload_command_handler)
 493 {
 494         unsigned int preload_length;
 495
 496         if (CMD_ARGC != 2)
 497                 return ERROR_COMMAND_SYNTAX_ERROR;
 498
 499         struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 500         if (!device) {
 501                 command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 502                 return ERROR_FAIL;
 503         }
 504
 505         COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], preload_length);
 506
 507         struct lattice_pld_device *lattice_device = device->driver_priv;
 508
 509         if (!lattice_device)
 510                 return ERROR_FAIL;
 511
 512         lattice_device->preload_length = preload_length;
 513
 514         return ERROR_OK;
 515 }
 516
 517 COMMAND_HANDLER(lattice_write_usercode_register_command_handler)
 518 {
 519         uint32_t usercode;
 520
 521         if (CMD_ARGC != 2)
 522                 return ERROR_COMMAND_SYNTAX_ERROR;
 523
 524         struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 525         if (!device) {
 526                 command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 527                 return ERROR_FAIL;
 528         }
 529
 530         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], usercode);
 531
 532         struct lattice_pld_device *lattice_device = device->driver_priv;
 533         if (!lattice_device)
 534                 return ERROR_FAIL;
 535
 536         int retval = lattice_check_device_family(lattice_device);
 537         if (retval != ERROR_OK)
 538                 return retval;
 539
 540         return lattice_write_usercode(lattice_device, usercode);
 541 }
 542
 543 COMMAND_HANDLER(lattice_read_status_command_handler)
 544 {
 545         if (CMD_ARGC != 1)
 546                 return ERROR_COMMAND_SYNTAX_ERROR;
 547
 548         struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 549         if (!device) {
 550                 command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 551                 return ERROR_FAIL;
 552         }
 553
 554         struct lattice_pld_device *lattice_device = device->driver_priv;
 555         if (!lattice_device)
 556                 return ERROR_FAIL;
 557
 558         int retval = lattice_check_device_family(lattice_device);
 559         if (retval != ERROR_OK)
 560                 return retval;
 561
 562         if (lattice_device->family == LATTICE_CERTUS) {
 563                 uint64_t status;
 564                 retval = lattice_read_status_u64(lattice_device, &status, 0x0);
 565                 if (retval == ERROR_OK)
 566                         command_print(CMD, "0x%016" PRIx64, status);
 567         } else {
 568                 uint32_t status;
 569                 const bool do_idle = lattice_device->family == LATTICE_ECP5;
 570                 retval = lattice_read_status_u32(lattice_device, &status, 0x0, do_idle);
 571                 if (retval == ERROR_OK)
 572                         command_print(CMD, "0x%8.8" PRIx32, status);
 573         }
 574
 575         return retval;
 576 }
 577
 578 COMMAND_HANDLER(lattice_refresh_command_handler)
 579 {
 580         if (CMD_ARGC != 1)
 581                 return ERROR_COMMAND_SYNTAX_ERROR;
 582
 583         struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 584         if (!device) {
 585                 command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 586                 return ERROR_FAIL;
 587         }
 588
 589         struct lattice_pld_device *lattice_device = device->driver_priv;
 590         if (!lattice_device)
 591                 return ERROR_FAIL;
 592
 593         int retval = lattice_check_device_family(lattice_device);
 594         if (retval != ERROR_OK)
 595                 return retval;
 596
 597         if (lattice_device->family == LATTICE_ECP2 || lattice_device->family == LATTICE_ECP3)
 598                 return lattice_ecp2_3_refresh(lattice_device);
 599         else if (lattice_device->family == LATTICE_ECP5)
 600                 return lattice_ecp5_refresh(lattice_device);
 601         else if (lattice_device->family == LATTICE_CERTUS)
 602                 return lattice_certus_refresh(lattice_device);
 603
 604         return ERROR_FAIL;
 605 }
 606
 607 static const struct command_registration lattice_exec_command_handlers[] = {
 608         {
 609                 .name = "read_status",
 610                 .mode = COMMAND_EXEC,
 611                 .handler = lattice_read_status_command_handler,
 612                 .help = "reading status register from FPGA",
 613                 .usage = "pld_name",
 614         }, {
 615                 .name = "read_user",
 616                 .mode = COMMAND_EXEC,
 617                 .handler = lattice_read_usercode_register_command_handler,
 618                 .help = "reading usercode register from FPGA",
 619                 .usage = "pld_name",
 620         }, {
 621                 .name = "write_user",
 622                 .mode = COMMAND_EXEC,
 623                 .handler = lattice_write_usercode_register_command_handler,
 624                 .help = "writing usercode register to FPGA",
 625                 .usage = "pld_name value",
 626         }, {
 627                 .name = "set_preload",
 628                 .mode = COMMAND_ANY,
 629                 .handler = lattice_set_preload_command_handler,
 630                 .help = "set length for preload (device specific)",
 631                 .usage = "pld_name value",
 632         }, {
 633                 .name = "refresh",
 634                 .mode = COMMAND_EXEC,
 635                 .handler = lattice_refresh_command_handler,
 636                 .help = "refresh from configuration memory",
 637                 .usage = "pld_name",
 638         },
 639         COMMAND_REGISTRATION_DONE
 640 };
 641
 642 static const struct command_registration lattice_command_handler[] = {
 643         {
 644                 .name = "lattice",
 645                 .mode = COMMAND_ANY,
 646                 .help = "lattice specific commands",
 647                 .usage = "",
 648                 .chain = lattice_exec_command_handlers,
 649         },
 650         COMMAND_REGISTRATION_DONE
 651 };
 652
 653 struct pld_driver lattice_pld = {
 654         .name = "lattice",
 655         .commands = lattice_command_handler,
 656         .pld_create_command = &lattice_pld_create_command,
 657         .load = &lattice_load_command,
 658         .get_ipdbg_hub = lattice_get_ipdbg_hub,
 659         .has_jtagspi_instruction = lattice_has_jtagspi_instruction,
 660         .connect_spi_to_jtag = lattice_connect_spi_to_jtag,
 661         .disconnect_spi_from_jtag = lattice_disconnect_spi_from_jtag,
 662         .get_stuff_bits = lattice_get_stuff_bits,
 663 };