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