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