src/xsvf/xsvf.c

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
   6  *   oyvind.harboe@zylin.com                                               *
   7  *                                                                         *
   8  *   Copyright (C) 2008 Peter Hettkamp                                     *
   9  *   peter.hettkamp@htp-tel.de                                             *
  10  *                                                                         *
  11  *   Copyright (C) 2009 SoftPLC Corporation. http://softplc.com            *
  12  *   Dick Hollenbeck <dick@softplc.com>                                    *
  13  *                                                                         *
  14  *   This program is free software; you can redistribute it and/or modify  *
  15  *   it under the terms of the GNU General Public License as published by  *
  16  *   the Free Software Foundation; either version 2 of the License, or     *
  17  *   (at your option) any later version.                                   *
  18  *                                                                         *
  19  *   This program is distributed in the hope that it will be useful,       *
  20  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  21  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  22  *   GNU General Public License for more details.                          *
  23  *                                                                         *
  24  *   You should have received a copy of the GNU General Public License     *
  25  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  26  ***************************************************************************/
  27
  28 /* The specification for SVF is available here:
  29  * http://www.asset-intertech.com/support/svf.pdf
  30  * Below, this document is referred to as the "SVF spec".
  31  *
  32  * The specification for XSVF is available here:
  33  * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
  34  * Below, this document is referred to as the "XSVF spec".
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include "xsvf.h"
  42 #include "helper/system.h"
  43 #include <jtag/jtag.h>
  44 #include <svf/svf.h>
  45
  46 /* XSVF commands, from appendix B of xapp503.pdf  */
  47 #define XCOMPLETE                       0x00
  48 #define XTDOMASK                        0x01
  49 #define XSIR                            0x02
  50 #define XSDR                            0x03
  51 #define XRUNTEST                        0x04
  52 #define XREPEAT                         0x07
  53 #define XSDRSIZE                        0x08
  54 #define XSDRTDO                         0x09
  55 #define XSETSDRMASKS            0x0A
  56 #define XSDRINC                         0x0B
  57 #define XSDRB                           0x0C
  58 #define XSDRC                           0x0D
  59 #define XSDRE                           0x0E
  60 #define XSDRTDOB                        0x0F
  61 #define XSDRTDOC                        0x10
  62 #define XSDRTDOE                        0x11
  63 #define XSTATE                          0x12
  64 #define XENDIR                          0x13
  65 #define XENDDR                          0x14
  66 #define XSIR2                           0x15
  67 #define XCOMMENT                        0x16
  68 #define XWAIT                           0x17
  69
  70 /* XWAITSTATE is not in the xilinx XSVF spec, but the svf2xsvf.py translator
  71  * generates this.  Arguably it is needed because the XSVF XRUNTEST command
  72  * was ill conceived and does not directly flow out of the SVF RUNTEST command.
  73  * This XWAITSTATE does map directly from the SVF RUNTEST command.
  74  */
  75 #define XWAITSTATE                      0x18
  76
  77 /* Lattice has extended the SVF file format, and Dick Hollenbeck's python based
  78  * SVF2XSVF converter supports these 3 additional XSVF opcodes, LCOUNT, LDELAY, LSDR.
  79  * Here is an example of usage of the 3 lattice opcode extensions:
  80
  81 ! Set the maximum loop count to 25.
  82 LCOUNT  25;
  83 ! Step to DRPAUSE give 5 clocks and wait for 1.00e + 000 SEC.
  84 LDELAY  DRPAUSE 5 TCK   1.00E-003 SEC;
  85 ! Test for the completed status. Match means pass.
  86 ! Loop back to LDELAY line if not match and loop count less than 25.
  87
  88 LSDR 1  TDI  (0)
  89 TDO  (1);
  90 */
  91
  92 #define LCOUNT                          0x19
  93 #define LDELAY                          0x1A
  94 #define LSDR                            0x1B
  95 #define XTRST                           0x1C
  96
  97 /* XSVF valid state values for the XSTATE command, from appendix B of xapp503.pdf */
  98 #define XSV_RESET                       0x00
  99 #define XSV_IDLE                        0x01
 100 #define XSV_DRSELECT            0x02
 101 #define XSV_DRCAPTURE           0x03
 102 #define XSV_DRSHIFT                     0x04
 103 #define XSV_DREXIT1                     0x05
 104 #define XSV_DRPAUSE                     0x06
 105 #define XSV_DREXIT2                     0x07
 106 #define XSV_DRUPDATE            0x08
 107 #define XSV_IRSELECT            0x09
 108 #define XSV_IRCAPTURE           0x0A
 109 #define XSV_IRSHIFT                     0x0B
 110 #define XSV_IREXIT1                     0x0C
 111 #define XSV_IRPAUSE                     0x0D
 112 #define XSV_IREXIT2                     0x0E
 113 #define XSV_IRUPDATE            0x0F
 114
 115 /* arguments to XTRST */
 116 #define XTRST_ON                        0
 117 #define XTRST_OFF                       1
 118 #define XTRST_Z                         2
 119 #define XTRST_ABSENT            3
 120
 121 #define XSTATE_MAX_PATH 12
 122
 123 static int xsvf_fd;
 124
 125 /* map xsvf tap state to an openocd "tap_state_t" */
 126 static tap_state_t xsvf_to_tap(int xsvf_state)
 127 {
 128         tap_state_t ret;
 129
 130         switch (xsvf_state) {
 131                 case XSV_RESET:
 132                         ret = TAP_RESET;
 133                         break;
 134                 case XSV_IDLE:
 135                         ret = TAP_IDLE;
 136                         break;
 137                 case XSV_DRSELECT:
 138                         ret = TAP_DRSELECT;
 139                         break;
 140                 case XSV_DRCAPTURE:
 141                         ret = TAP_DRCAPTURE;
 142                         break;
 143                 case XSV_DRSHIFT:
 144                         ret = TAP_DRSHIFT;
 145                         break;
 146                 case XSV_DREXIT1:
 147                         ret = TAP_DREXIT1;
 148                         break;
 149                 case XSV_DRPAUSE:
 150                         ret = TAP_DRPAUSE;
 151                         break;
 152                 case XSV_DREXIT2:
 153                         ret = TAP_DREXIT2;
 154                         break;
 155                 case XSV_DRUPDATE:
 156                         ret = TAP_DRUPDATE;
 157                         break;
 158                 case XSV_IRSELECT:
 159                         ret = TAP_IRSELECT;
 160                         break;
 161                 case XSV_IRCAPTURE:
 162                         ret = TAP_IRCAPTURE;
 163                         break;
 164                 case XSV_IRSHIFT:
 165                         ret = TAP_IRSHIFT;
 166                         break;
 167                 case XSV_IREXIT1:
 168                         ret = TAP_IREXIT1;
 169                         break;
 170                 case XSV_IRPAUSE:
 171                         ret = TAP_IRPAUSE;
 172                         break;
 173                 case XSV_IREXIT2:
 174                         ret = TAP_IREXIT2;
 175                         break;
 176                 case XSV_IRUPDATE:
 177                         ret = TAP_IRUPDATE;
 178                         break;
 179                 default:
 180                         LOG_ERROR("UNKNOWN XSVF STATE 0x%02X", xsvf_state);
 181                         exit(1);
 182         }
 183
 184         return ret;
 185 }
 186
 187 static int xsvf_read_buffer(int num_bits, int fd, uint8_t *buf)
 188 {
 189         int num_bytes;
 190
 191         for (num_bytes = (num_bits + 7) / 8; num_bytes > 0; num_bytes--) {
 192                 /* reverse the order of bytes as they are read sequentially from file */
 193                 if (read(fd, buf + num_bytes - 1, 1) < 0)
 194                         return ERROR_XSVF_EOF;
 195         }
 196
 197         return ERROR_OK;
 198 }
 199
 200 COMMAND_HANDLER(handle_xsvf_command)
 201 {
 202         uint8_t *dr_out_buf = NULL;                             /* from host to device (TDI) */
 203         uint8_t *dr_in_buf = NULL;                              /* from device to host (TDO) */
 204         uint8_t *dr_in_mask = NULL;
 205
 206         int xsdrsize = 0;
 207         int xruntest = 0;                                       /* number of TCK cycles OR *microseconds */
 208         int xrepeat = 0;                                        /* number of retries */
 209
 210         tap_state_t xendir = TAP_IDLE;                  /* see page 8 of the SVF spec, initial
 211                                                          *xendir to be TAP_IDLE */
 212         tap_state_t xenddr = TAP_IDLE;
 213
 214         uint8_t opcode;
 215         uint8_t uc = 0;
 216         long file_offset = 0;
 217
 218         int loop_count = 0;
 219         tap_state_t loop_state = TAP_IDLE;
 220         int loop_clocks = 0;
 221         int loop_usecs = 0;
 222
 223         int do_abort = 0;
 224         int unsupported = 0;
 225         int tdo_mismatch = 0;
 226         int result;
 227         int verbose = 1;
 228
 229         bool collecting_path = false;
 230         tap_state_t path[XSTATE_MAX_PATH];
 231         unsigned pathlen = 0;
 232
 233         /* a flag telling whether to clock TCK during waits,
 234          * or simply sleep, controlled by virt2
 235          */
 236         int runtest_requires_tck = 0;
 237
 238         /* use NULL to indicate a "plain" xsvf file which accounts for
 239          * additional devices in the scan chain, otherwise the device
 240          * that should be affected
 241         */
 242         struct jtag_tap *tap = NULL;
 243
 244         if (CMD_ARGC < 2)
 245                 return ERROR_COMMAND_SYNTAX_ERROR;
 246
 247         /* we mess with CMD_ARGV starting point below, snapshot filename here */
 248         const char *filename = CMD_ARGV[1];
 249
 250         if (strcmp(CMD_ARGV[0], "plain") != 0) {
 251                 tap = jtag_tap_by_string(CMD_ARGV[0]);
 252                 if (!tap) {
 253                         command_print(CMD, "Tap: %s unknown", CMD_ARGV[0]);
 254                         return ERROR_FAIL;
 255                 }
 256         }
 257
 258         xsvf_fd = open(filename, O_RDONLY);
 259         if (xsvf_fd < 0) {
 260                 command_print(CMD, "file \"%s\" not found", filename);
 261                 return ERROR_FAIL;
 262         }
 263
 264         /* if this argument is present, then interpret xruntest counts as TCK cycles rather than as
 265          *usecs */
 266         if ((CMD_ARGC > 2) && (strcmp(CMD_ARGV[2], "virt2") == 0)) {
 267                 runtest_requires_tck = 1;
 268                 --CMD_ARGC;
 269                 ++CMD_ARGV;
 270         }
 271
 272         if ((CMD_ARGC > 2) && (strcmp(CMD_ARGV[2], "quiet") == 0))
 273                 verbose = 0;
 274
 275         LOG_WARNING("XSVF support in OpenOCD is limited. Consider using SVF instead");
 276         LOG_USER("xsvf processing file: \"%s\"", filename);
 277
 278         while (read(xsvf_fd, &opcode, 1) > 0) {
 279                 /* record the position of this opcode within the file */
 280                 file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
 281
 282                 /* maybe collect another state for a pathmove();
 283                  * or terminate a path.
 284                  */
 285                 if (collecting_path) {
 286                         tap_state_t mystate;
 287
 288                         switch (opcode) {
 289                                 case XCOMMENT:
 290                                         /* ignore/show comments between XSTATE ops */
 291                                         break;
 292                                 case XSTATE:
 293                                         /* try to collect another transition */
 294                                         if (pathlen == XSTATE_MAX_PATH) {
 295                                                 LOG_ERROR("XSVF: path too long");
 296                                                 do_abort = 1;
 297                                                 break;
 298                                         }
 299
 300                                         if (read(xsvf_fd, &uc, 1) < 0) {
 301                                                 do_abort = 1;
 302                                                 break;
 303                                         }
 304
 305                                         mystate = xsvf_to_tap(uc);
 306                                         path[pathlen++] = mystate;
 307
 308                                         LOG_DEBUG("XSTATE 0x%02X %s", uc,
 309                                         tap_state_name(mystate));
 310
 311                                         /* If path is incomplete, collect more */
 312                                         if (!svf_tap_state_is_stable(mystate))
 313                                                 continue;
 314
 315                                         /* Else execute the path transitions we've
 316                                          * collected so far.
 317                                          *
 318                                          * NOTE:  Punting on the saved path is not
 319                                          * strictly correct, but we must to do this
 320                                          * unless jtag_add_pathmove() stops rejecting
 321                                          * paths containing RESET.  This is probably
 322                                          * harmless, since there aren't many options
 323                                          * for going from a stable state to reset;
 324                                          * at the worst, we may issue extra clocks
 325                                          * once we get to RESET.
 326                                          */
 327                                         if (mystate == TAP_RESET) {
 328                                                 LOG_WARNING("XSVF: dodgey RESET");
 329                                                 path[0] = mystate;
 330                                         }
 331
 332                                 /* FALL THROUGH */
 333                                 default:
 334                                         /* Execute the path we collected
 335                                          *
 336                                          * NOTE: OpenOCD requires something that XSVF
 337                                          * doesn't:  the last TAP state in the path
 338                                          * must be stable.  In practice, tools that
 339                                          * create XSVF seem to follow that rule too.
 340                                          */
 341                                         collecting_path = false;
 342
 343                                         if (path[0] == TAP_RESET)
 344                                                 jtag_add_tlr();
 345                                         else
 346                                                 jtag_add_pathmove(pathlen, path);
 347
 348                                         result = jtag_execute_queue();
 349                                         if (result != ERROR_OK) {
 350                                                 LOG_ERROR("XSVF: pathmove error %d", result);
 351                                                 do_abort = 1;
 352                                                 break;
 353                                         }
 354                                         continue;
 355                         }
 356                 }
 357
 358                 switch (opcode) {
 359                         case XCOMPLETE:
 360                                 LOG_DEBUG("XCOMPLETE");
 361
 362                                 result = jtag_execute_queue();
 363                                 if (result != ERROR_OK) {
 364                                         tdo_mismatch = 1;
 365                                         break;
 366                                 }
 367                                 break;
 368
 369                         case XTDOMASK:
 370                                 LOG_DEBUG("XTDOMASK");
 371                                 if (dr_in_mask &&
 372                                                 (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
 373                                         do_abort = 1;
 374                                 break;
 375
 376                         case XRUNTEST:
 377                         {
 378                                 uint8_t xruntest_buf[4];
 379
 380                                 if (read(xsvf_fd, xruntest_buf, 4) < 0) {
 381                                         do_abort = 1;
 382                                         break;
 383                                 }
 384
 385                                 xruntest = be_to_h_u32(xruntest_buf);
 386                                 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
 387                         }
 388                         break;
 389
 390                         case XREPEAT:
 391                         {
 392                                 uint8_t myrepeat;
 393
 394                                 if (read(xsvf_fd, &myrepeat, 1) < 0)
 395                                         do_abort = 1;
 396                                 else {
 397                                         xrepeat = myrepeat;
 398                                         LOG_DEBUG("XREPEAT %d", xrepeat);
 399                                 }
 400                         }
 401                         break;
 402
 403                         case XSDRSIZE:
 404                         {
 405                                 uint8_t xsdrsize_buf[4];
 406
 407                                 if (read(xsvf_fd, xsdrsize_buf, 4) < 0) {
 408                                         do_abort = 1;
 409                                         break;
 410                                 }
 411
 412                                 xsdrsize = be_to_h_u32(xsdrsize_buf);
 413                                 LOG_DEBUG("XSDRSIZE %d", xsdrsize);
 414
 415                                 free(dr_out_buf);
 416                                 free(dr_in_buf);
 417                                 free(dr_in_mask);
 418
 419                                 dr_out_buf = malloc((xsdrsize + 7) / 8);
 420                                 dr_in_buf = malloc((xsdrsize + 7) / 8);
 421                                 dr_in_mask = malloc((xsdrsize + 7) / 8);
 422                         }
 423                         break;
 424
 425                         case XSDR:              /* these two are identical except for the dr_in_buf */
 426                         case XSDRTDO:
 427                         {
 428                                 int limit = xrepeat;
 429                                 int matched = 0;
 430                                 int attempt;
 431
 432                                 const char *op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
 433
 434                                 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK) {
 435                                         do_abort = 1;
 436                                         break;
 437                                 }
 438
 439                                 if (opcode == XSDRTDO) {
 440                                         if (xsvf_read_buffer(xsdrsize, xsvf_fd,
 441                                                 dr_in_buf)  != ERROR_OK) {
 442                                                 do_abort = 1;
 443                                                 break;
 444                                         }
 445                                 }
 446
 447                                 if (limit < 1)
 448                                         limit = 1;
 449
 450                                 LOG_DEBUG("%s %d", op_name, xsdrsize);
 451
 452                                 for (attempt = 0; attempt < limit; ++attempt) {
 453                                         struct scan_field field;
 454
 455                                         if (attempt > 0) {
 456                                                 /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
 457                                                  * illustrated in pseudo code at end of this file.  We start from state
 458                                                  * DRPAUSE:
 459                                                  * go to Exit2-DR
 460                                                  * go to Shift-DR
 461                                                  * go to Exit1-DR
 462                                                  * go to Update-DR
 463                                                  * go to Run-Test/Idle
 464                                                  *
 465                                                  * This sequence should be harmless for other devices, and it
 466                                                  * will be skipped entirely if xrepeat is set to zero.
 467                                                  */
 468
 469                                                 static tap_state_t exception_path[] = {
 470                                                         TAP_DREXIT2,
 471                                                         TAP_DRSHIFT,
 472                                                         TAP_DREXIT1,
 473                                                         TAP_DRUPDATE,
 474                                                         TAP_IDLE,
 475                                                 };
 476
 477                                                 jtag_add_pathmove(ARRAY_SIZE(exception_path), exception_path);
 478
 479                                                 if (verbose)
 480                                                         LOG_USER("%s mismatch, xsdrsize=%d retry=%d",
 481                                                                         op_name,
 482                                                                         xsdrsize,
 483                                                                         attempt);
 484                                         }
 485
 486                                         field.num_bits = xsdrsize;
 487                                         field.out_value = dr_out_buf;
 488                                         field.in_value = calloc(DIV_ROUND_UP(field.num_bits, 8), 1);
 489
 490                                         if (tap == NULL)
 491                                                 jtag_add_plain_dr_scan(field.num_bits,
 492                                                                 field.out_value,
 493                                                                 field.in_value,
 494                                                                 TAP_DRPAUSE);
 495                                         else
 496                                                 jtag_add_dr_scan(tap, 1, &field, TAP_DRPAUSE);
 497
 498                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 499
 500                                         free(field.in_value);
 501
 502                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 503                                         result = jtag_execute_queue();
 504                                         if (result == ERROR_OK) {
 505                                                 matched = 1;
 506                                                 break;
 507                                         }
 508                                 }
 509
 510                                 if (!matched) {
 511                                         LOG_USER("%s mismatch", op_name);
 512                                         tdo_mismatch = 1;
 513                                         break;
 514                                 }
 515
 516                                 /* See page 19 of XSVF spec regarding opcode "XSDR" */
 517                                 if (xruntest) {
 518                                         result = svf_add_statemove(TAP_IDLE);
 519                                         if (result != ERROR_OK)
 520                                                 return result;
 521
 522                                         if (runtest_requires_tck)
 523                                                 jtag_add_clocks(xruntest);
 524                                         else
 525                                                 jtag_add_sleep(xruntest);
 526                                 } else if (xendir != TAP_DRPAUSE) {
 527                                         /* we are already in TAP_DRPAUSE */
 528                                         result = svf_add_statemove(xenddr);
 529                                         if (result != ERROR_OK)
 530                                                 return result;
 531                                 }
 532                         }
 533                         break;
 534
 535                         case XSETSDRMASKS:
 536                                 LOG_ERROR("unsupported XSETSDRMASKS");
 537                                 unsupported = 1;
 538                                 break;
 539
 540                         case XSDRINC:
 541                                 LOG_ERROR("unsupported XSDRINC");
 542                                 unsupported = 1;
 543                                 break;
 544
 545                         case XSDRB:
 546                                 LOG_ERROR("unsupported XSDRB");
 547                                 unsupported = 1;
 548                                 break;
 549
 550                         case XSDRC:
 551                                 LOG_ERROR("unsupported XSDRC");
 552                                 unsupported = 1;
 553                                 break;
 554
 555                         case XSDRE:
 556                                 LOG_ERROR("unsupported XSDRE");
 557                                 unsupported = 1;
 558                                 break;
 559
 560                         case XSDRTDOB:
 561                                 LOG_ERROR("unsupported XSDRTDOB");
 562                                 unsupported = 1;
 563                                 break;
 564
 565                         case XSDRTDOC:
 566                                 LOG_ERROR("unsupported XSDRTDOC");
 567                                 unsupported = 1;
 568                                 break;
 569
 570                         case XSDRTDOE:
 571                                 LOG_ERROR("unsupported XSDRTDOE");
 572                                 unsupported = 1;
 573                                 break;
 574
 575                         case XSTATE:
 576                         {
 577                                 tap_state_t mystate;
 578
 579                                 if (read(xsvf_fd, &uc, 1) < 0) {
 580                                         do_abort = 1;
 581                                         break;
 582                                 }
 583
 584                                 mystate = xsvf_to_tap(uc);
 585
 586                                 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate));
 587
 588                                 if (mystate == TAP_INVALID) {
 589                                         LOG_ERROR("XSVF: bad XSTATE %02x", uc);
 590                                         do_abort = 1;
 591                                         break;
 592                                 }
 593
 594                                 /* NOTE: the current state is SVF-stable! */
 595
 596                                 /* no change == NOP */
 597                                 if (mystate == cmd_queue_cur_state
 598                                                 && mystate != TAP_RESET)
 599                                         break;
 600
 601                                 /* Hand off to SVF? */
 602                                 if (svf_tap_state_is_stable(mystate)) {
 603                                         result = svf_add_statemove(mystate);
 604                                         if (result != ERROR_OK)
 605                                                 unsupported = 1;
 606                                         break;
 607                                 }
 608
 609                                 /*
 610                                  * A sequence of XSTATE transitions, each TAP
 611                                  * state adjacent to the previous one.  Start
 612                                  * collecting them.
 613                                  */
 614                                 collecting_path = true;
 615                                 pathlen = 1;
 616                                 path[0] = mystate;
 617                         }
 618                         break;
 619
 620                         case XENDIR:
 621
 622                                 if (read(xsvf_fd, &uc, 1) < 0) {
 623                                         do_abort = 1;
 624                                         break;
 625                                 }
 626
 627                                 /* see page 22 of XSVF spec */
 628                                 if (uc == 0)
 629                                         xendir = TAP_IDLE;
 630                                 else if (uc == 1)
 631                                         xendir = TAP_IRPAUSE;
 632                                 else {
 633                                         LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
 634                                         unsupported = 1;
 635                                         break;
 636                                 }
 637
 638                                 LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
 639                                 break;
 640
 641                         case XENDDR:
 642
 643                                 if (read(xsvf_fd, &uc, 1) < 0) {
 644                                         do_abort = 1;
 645                                         break;
 646                                 }
 647
 648                                 /* see page 22 of XSVF spec */
 649                                 if (uc == 0)
 650                                         xenddr = TAP_IDLE;
 651                                 else if (uc == 1)
 652                                         xenddr = TAP_DRPAUSE;
 653                                 else {
 654                                         LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
 655                                         unsupported = 1;
 656                                         break;
 657                                 }
 658
 659                                 LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
 660                                 break;
 661
 662                         case XSIR:
 663                         case XSIR2:
 664                         {
 665                                 uint8_t short_buf[2];
 666                                 uint8_t *ir_buf;
 667                                 int bitcount;
 668                                 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
 669
 670                                 if (opcode == XSIR) {
 671                                         /* one byte bitcount */
 672                                         if (read(xsvf_fd, short_buf, 1) < 0) {
 673                                                 do_abort = 1;
 674                                                 break;
 675                                         }
 676                                         bitcount = short_buf[0];
 677                                         LOG_DEBUG("XSIR %d", bitcount);
 678                                 } else {
 679                                         if (read(xsvf_fd, short_buf, 2) < 0) {
 680                                                 do_abort = 1;
 681                                                 break;
 682                                         }
 683                                         bitcount = be_to_h_u16(short_buf);
 684                                         LOG_DEBUG("XSIR2 %d", bitcount);
 685                                 }
 686
 687                                 ir_buf = malloc((bitcount + 7) / 8);
 688
 689                                 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
 690                                         do_abort = 1;
 691                                 else {
 692                                         struct scan_field field;
 693
 694                                         field.num_bits = bitcount;
 695                                         field.out_value = ir_buf;
 696
 697                                         field.in_value = NULL;
 698
 699                                         if (tap == NULL)
 700                                                 jtag_add_plain_ir_scan(field.num_bits,
 701                                                                 field.out_value, field.in_value, my_end_state);
 702                                         else
 703                                                 jtag_add_ir_scan(tap, &field, my_end_state);
 704
 705                                         if (xruntest) {
 706                                                 if (runtest_requires_tck)
 707                                                         jtag_add_clocks(xruntest);
 708                                                 else
 709                                                         jtag_add_sleep(xruntest);
 710                                         }
 711
 712                                         /* Note that an -irmask of non-zero in your config file
 713                                          * can cause this to fail.  Setting -irmask to zero cand work
 714                                          * around the problem.
 715                                          */
 716
 717                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 718                                         result = jtag_execute_queue();
 719                                         if (result != ERROR_OK)
 720                                                 tdo_mismatch = 1;
 721                                 }
 722                                 free(ir_buf);
 723                         }
 724                         break;
 725
 726                         case XCOMMENT:
 727                         {
 728                                 unsigned int ndx = 0;
 729                                 char comment[128];
 730
 731                                 do {
 732                                         if (read(xsvf_fd, &uc, 1) < 0) {
 733                                                 do_abort = 1;
 734                                                 break;
 735                                         }
 736
 737                                         if (ndx < sizeof(comment)-1)
 738                                                 comment[ndx++] = uc;
 739
 740                                 } while (uc != 0);
 741
 742                                 comment[sizeof(comment)-1] = 0;         /* regardless, terminate */
 743                                 if (verbose)
 744                                         LOG_USER("# %s", comment);
 745                         }
 746                         break;
 747
 748                         case XWAIT:
 749                         {
 750                                 /* expected in stream:
 751                                    XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
 752                                 */
 753
 754                                 uint8_t wait_local;
 755                                 uint8_t end;
 756                                 uint8_t delay_buf[4];
 757
 758                                 tap_state_t wait_state;
 759                                 tap_state_t end_state;
 760                                 int delay;
 761
 762                                 if (read(xsvf_fd, &wait_local, 1) < 0
 763                                         || read(xsvf_fd, &end, 1) < 0
 764                                         || read(xsvf_fd, delay_buf, 4) < 0) {
 765                                                 do_abort = 1;
 766                                                 break;
 767                                 }
 768
 769                                 wait_state = xsvf_to_tap(wait_local);
 770                                 end_state  = xsvf_to_tap(end);
 771                                 delay = be_to_h_u32(delay_buf);
 772
 773                                 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(
 774                                                 wait_state), tap_state_name(end_state), delay);
 775
 776                                 if (runtest_requires_tck && wait_state == TAP_IDLE)
 777                                         jtag_add_runtest(delay, end_state);
 778                                 else {
 779                                         /* FIXME handle statemove errors ... */
 780                                         result = svf_add_statemove(wait_state);
 781                                         if (result != ERROR_OK)
 782                                                 return result;
 783                                         jtag_add_sleep(delay);
 784                                         result = svf_add_statemove(end_state);
 785                                         if (result != ERROR_OK)
 786                                                 return result;
 787                                 }
 788                         }
 789                         break;
 790
 791                         case XWAITSTATE:
 792                         {
 793                                 /* expected in stream:
 794                                  * XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count>
 795                                  * <uint32_t usecs>
 796                                 */
 797
 798                                 uint8_t clock_buf[4];
 799                                 uint8_t usecs_buf[4];
 800                                 uint8_t wait_local;
 801                                 uint8_t end;
 802                                 tap_state_t wait_state;
 803                                 tap_state_t end_state;
 804                                 int clock_count;
 805                                 int usecs;
 806
 807                                 if (read(xsvf_fd, &wait_local, 1) < 0
 808                                                 ||  read(xsvf_fd, &end, 1) < 0
 809                                                 ||  read(xsvf_fd, clock_buf, 4) < 0
 810                                                 ||  read(xsvf_fd, usecs_buf, 4) < 0) {
 811                                         do_abort = 1;
 812                                         break;
 813                                 }
 814
 815                                 wait_state = xsvf_to_tap(wait_local);
 816                                 end_state  = xsvf_to_tap(end);
 817
 818                                 clock_count = be_to_h_u32(clock_buf);
 819                                 usecs = be_to_h_u32(usecs_buf);
 820
 821                                 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
 822                                                 tap_state_name(wait_state),
 823                                                 tap_state_name(end_state),
 824                                                 clock_count, usecs);
 825
 826                                 /* the following states are 'stable', meaning that they have a transition
 827                                  * in the state diagram back to themselves.  This is necessary because we will
 828                                  * be issuing a number of clocks in this state.  This set of allowed states is also
 829                                  * determined by the SVF RUNTEST command's allowed states.
 830                                  */
 831                                 if (!svf_tap_state_is_stable(wait_state)) {
 832                                         LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"",
 833                                                         tap_state_name(wait_state));
 834                                         unsupported = 1;
 835                                         /* REVISIT "break" so we won't run? */
 836                                 }
 837
 838                                 /* FIXME handle statemove errors ... */
 839                                 result = svf_add_statemove(wait_state);
 840                                 if (result != ERROR_OK)
 841                                         return result;
 842
 843                                 jtag_add_clocks(clock_count);
 844                                 jtag_add_sleep(usecs);
 845
 846                                 result = svf_add_statemove(end_state);
 847                                 if (result != ERROR_OK)
 848                                         return result;
 849                         }
 850                         break;
 851
 852                         case LCOUNT:
 853                         {
 854                                 /* expected in stream:
 855                                  * LCOUNT <uint32_t loop_count>
 856                                 */
 857                                 uint8_t count_buf[4];
 858
 859                                 if (read(xsvf_fd, count_buf, 4) < 0) {
 860                                         do_abort = 1;
 861                                         break;
 862                                 }
 863
 864                                 loop_count = be_to_h_u32(count_buf);
 865                                 LOG_DEBUG("LCOUNT %d", loop_count);
 866                         }
 867                         break;
 868
 869                         case LDELAY:
 870                         {
 871                                 /* expected in stream:
 872                                  * LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
 873                                 */
 874                                 uint8_t state;
 875                                 uint8_t clock_buf[4];
 876                                 uint8_t usecs_buf[4];
 877
 878                                 if (read(xsvf_fd, &state, 1) < 0
 879                                                 || read(xsvf_fd, clock_buf, 4) < 0
 880                                                 || read(xsvf_fd, usecs_buf, 4) < 0) {
 881                                         do_abort = 1;
 882                                         break;
 883                                 }
 884
 885                                 /* NOTE:  loop_state must be stable! */
 886                                 loop_state  = xsvf_to_tap(state);
 887                                 loop_clocks = be_to_h_u32(clock_buf);
 888                                 loop_usecs  = be_to_h_u32(usecs_buf);
 889
 890                                 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(
 891                                                 loop_state), loop_clocks, loop_usecs);
 892                         }
 893                         break;
 894
 895                         /* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
 896                          * comes with clocks !AND! sleep requirements.
 897                          */
 898                         case LSDR:
 899                         {
 900                                 int limit = loop_count;
 901                                 int matched = 0;
 902                                 int attempt;
 903
 904                                 LOG_DEBUG("LSDR");
 905
 906                                 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
 907                                                 || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK) {
 908                                         do_abort = 1;
 909                                         break;
 910                                 }
 911
 912                                 if (limit < 1)
 913                                         limit = 1;
 914
 915                                 for (attempt = 0; attempt < limit; ++attempt) {
 916                                         struct scan_field field;
 917
 918                                         result = svf_add_statemove(loop_state);
 919                                         if (result != ERROR_OK) {
 920                                                 free(dr_in_mask);
 921                                                 return result;
 922                                         }
 923                                         jtag_add_clocks(loop_clocks);
 924                                         jtag_add_sleep(loop_usecs);
 925
 926                                         field.num_bits = xsdrsize;
 927                                         field.out_value = dr_out_buf;
 928                                         field.in_value = calloc(DIV_ROUND_UP(field.num_bits, 8), 1);
 929
 930                                         if (attempt > 0 && verbose)
 931                                                 LOG_USER("LSDR retry %d", attempt);
 932
 933                                         if (tap == NULL)
 934                                                 jtag_add_plain_dr_scan(field.num_bits,
 935                                                                 field.out_value,
 936                                                                 field.in_value,
 937                                                                 TAP_DRPAUSE);
 938                                         else
 939                                                 jtag_add_dr_scan(tap, 1, &field, TAP_DRPAUSE);
 940
 941                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 942
 943                                         free(field.in_value);
 944
 945
 946                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 947                                         result = jtag_execute_queue();
 948                                         if (result == ERROR_OK) {
 949                                                 matched = 1;
 950                                                 break;
 951                                         }
 952                                 }
 953
 954                                 if (!matched) {
 955                                         LOG_USER("LSDR mismatch");
 956                                         tdo_mismatch = 1;
 957                                         break;
 958                                 }
 959                         }
 960                         break;
 961
 962                         case XTRST:
 963                         {
 964                                 uint8_t trst_mode;
 965
 966                                 if (read(xsvf_fd, &trst_mode, 1) < 0) {
 967                                         do_abort = 1;
 968                                         break;
 969                                 }
 970
 971                                 switch (trst_mode) {
 972                                 case XTRST_ON:
 973                                         jtag_add_reset(1, 0);
 974                                         break;
 975                                 case XTRST_OFF:
 976                                 case XTRST_Z:
 977                                         jtag_add_reset(0, 0);
 978                                         break;
 979                                 case XTRST_ABSENT:
 980                                         break;
 981                                 default:
 982                                         LOG_ERROR("XTRST mode argument (0x%02X) out of range", trst_mode);
 983                                         do_abort = 1;
 984                                 }
 985                         }
 986                         break;
 987
 988                         default:
 989                                 LOG_ERROR("unknown xsvf command (0x%02X)", uc);
 990                                 unsupported = 1;
 991                 }
 992
 993                 if (do_abort || unsupported || tdo_mismatch) {
 994                         LOG_DEBUG("xsvf failed, setting taps to reasonable state");
 995
 996                         /* upon error, return the TAPs to a reasonable state */
 997                         result = svf_add_statemove(TAP_IDLE);
 998                         if (result != ERROR_OK)
 999                                 return result;
1000                         result = jtag_execute_queue();
1001                         if (result != ERROR_OK)
1002                                 return result;
1003                         break;
1004                 }
1005         }
1006
1007         if (tdo_mismatch) {
1008                 command_print(CMD,
1009                         "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1010                         file_offset);
1011
1012                 return ERROR_FAIL;
1013         }
1014
1015         if (unsupported) {
1016                 off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
1017                 command_print(CMD,
1018                         "unsupported xsvf command (0x%02X) at offset %jd, aborting",
1019                         uc, (intmax_t)offset);
1020                 return ERROR_FAIL;
1021         }
1022
1023         if (do_abort) {
1024                 command_print(CMD, "premature end of xsvf file detected, aborting");
1025                 return ERROR_FAIL;
1026         }
1027
1028         free(dr_out_buf);
1029         free(dr_in_buf);
1030         free(dr_in_mask);
1031
1032         close(xsvf_fd);
1033
1034         command_print(CMD, "XSVF file programmed successfully");
1035
1036         return ERROR_OK;
1037 }
1038
1039 static const struct command_registration xsvf_command_handlers[] = {
1040         {
1041                 .name = "xsvf",
1042                 .handler = handle_xsvf_command,
1043                 .mode = COMMAND_EXEC,
1044                 .help = "Runs a XSVF file.  If 'virt2' is given, xruntest "
1045                         "counts are interpreted as TCK cycles rather than "
1046                         "as microseconds.  Without the 'quiet' option, all "
1047                         "comments, retries, and mismatches will be reported.",
1048                 .usage = "(tapname|'plain') filename ['virt2'] ['quiet']",
1049         },
1050         COMMAND_REGISTRATION_DONE
1051 };
1052
1053 int xsvf_register_commands(struct command_context *cmd_ctx)
1054 {
1055         return register_commands(cmd_ctx, NULL, xsvf_command_handlers);
1056 }
1057
1058 /*
1059
1060 PSUEDO-Code from Xilinx Appnote XAPP067.pdf :
1061
1062 the following pseudo code clarifies the intent of the xrepeat support.The
1063 flow given is for the entire processing of an SVF file, not an XSVF file.
1064 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1065
1066 "Pseudo-Code Algorithm for SVF-Based ISP"
1067
1068 1. Go to Test-Logic-Reset state
1069 2. Go to Run-Test Idle state
1070 3. Read SVF record
1071
1072 4. if SIR record then
1073 go to Shift-IR state
1074 Scan in <TDI value>
1075
1076 5. else if SDR record then
1077 set <repeat count> to 0
1078 store <TDI value> as <current TDI value>
1079 store <TDO value> as <current TDO value>
1080 6. go to Shift-DR state
1081 scan in <current TDI value>
1082 if < current TDO value > is specified then
1083 if < current TDO value > does not equal <actual TDO value> then
1084 if < repeat count > > 32 then
1085 LOG ERROR
1086 go to Run-Test Idle state
1087 go to Step 3
1088 end if
1089 go to Pause-DR
1090 go to Exit2-DR
1091 go to Shift-DR
1092 go to Exit1-DR
1093 go to Update-DR
1094 go to Run-Test/Idle
1095 increment <repeat count> by 1
1096 pause <current pause time> microseconds
1097 go to Step 6)
1098 end if
1099 else
1100         go to Run-Test Idle state
1101         go to Step 3
1102         endif
1103         else if RUNTEST record then
1104         pause tester for < TCK value > microseconds
1105         store <TCK value> as <current pause time>
1106         end if
1107
1108 */