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                         uint8_t         uc;
 273
 274                         switch (opcode) {
 275                         case XCOMMENT:
 276                                 /* ignore/show comments between XSTATE ops */
 277                                 break;
 278                         case XSTATE:
 279                                 /* try to collect another transition */
 280                                 if (pathlen == XSTATE_MAX_PATH) {
 281                                         LOG_ERROR("XSVF: path too long");
 282                                         do_abort = 1;
 283                                         break;
 284                                 }
 285
 286                                 if (read(xsvf_fd, &uc, 1) < 0)
 287                                 {
 288                                         do_abort = 1;
 289                                         break;
 290                                 }
 291
 292                                 mystate = xsvf_to_tap(uc);
 293                                 path[pathlen++] = mystate;
 294
 295                                 LOG_DEBUG("XSTATE 0x%02X %s", uc,
 296                                                 tap_state_name(mystate));
 297
 298                                 /* If path is incomplete, collect more */
 299                                 if (!svf_tap_state_is_stable(mystate))
 300                                         continue;
 301
 302                                 /* Else execute the path transitions we've
 303                                  * collected so far.
 304                                  *
 305                                  * NOTE:  Punting on the saved path is not
 306                                  * strictly correct, but we must to do this
 307                                  * unless jtag_add_pathmove() stops rejecting
 308                                  * paths containing RESET.  This is probably
 309                                  * harmless, since there aren't many options
 310                                  * for going from a stable state to reset;
 311                                  * at the worst, we may issue extra clocks
 312                                  * once we get to RESET.
 313                                  */
 314                                 if (mystate == TAP_RESET) {
 315                                         LOG_WARNING("XSVF: dodgey RESET");
 316                                         path[0] = mystate;
 317                                 }
 318
 319                                 /* FALL THROUGH */
 320                         default:
 321                                 /* Execute the path we collected
 322                                  *
 323                                  * NOTE: OpenOCD requires something that XSVF
 324                                  * doesn't:  the last TAP state in the path
 325                                  * must be stable.  In practice, tools that
 326                                  * create XSVF seem to follow that rule too.
 327                                  */
 328                                 collecting_path = false;
 329
 330                                 if (path[0] == TAP_RESET)
 331                                         jtag_add_tlr();
 332                                 else
 333                                         jtag_add_pathmove(pathlen, path);
 334
 335                                 result = jtag_get_error();
 336                                 if (result != ERROR_OK) {
 337                                         LOG_ERROR("XSVF: pathmove error %d",
 338                                                         result);
 339                                         do_abort = 1;
 340                                         break;
 341                                 }
 342                                 continue;
 343                         }
 344                 }
 345
 346                 switch (opcode)
 347                 {
 348                 case XCOMPLETE:
 349                         LOG_DEBUG("XCOMPLETE");
 350
 351                         result = jtag_execute_queue();
 352                         if (result != ERROR_OK)
 353                         {
 354                                 tdo_mismatch = 1;
 355                                 break;
 356                         }
 357                         break;
 358
 359                 case XTDOMASK:
 360                         LOG_DEBUG("XTDOMASK");
 361                         if (dr_in_mask && (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
 362                                 do_abort = 1;
 363                         break;
 364
 365                 case XRUNTEST:
 366                         {
 367                                 uint8_t xruntest_buf[4];
 368
 369                                 if (read(xsvf_fd, xruntest_buf, 4) < 0)
 370                                 {
 371                                         do_abort = 1;
 372                                         break;
 373                                 }
 374
 375                                 xruntest = be_to_h_u32(xruntest_buf);
 376                                 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
 377                         }
 378                         break;
 379
 380                 case XREPEAT:
 381                         {
 382                                 uint8_t myrepeat;
 383
 384                                 if (read(xsvf_fd, &myrepeat, 1) < 0)
 385                                         do_abort = 1;
 386                                 else
 387                                 {
 388                                         xrepeat = myrepeat;
 389                                         LOG_DEBUG("XREPEAT %d", xrepeat);
 390                                 }
 391                         }
 392                         break;
 393
 394                 case XSDRSIZE:
 395                         {
 396                                 uint8_t xsdrsize_buf[4];
 397
 398                                 if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
 399                                 {
 400                                         do_abort = 1;
 401                                         break;
 402                                 }
 403
 404                                 xsdrsize = be_to_h_u32(xsdrsize_buf);
 405                                 LOG_DEBUG("XSDRSIZE %d", xsdrsize);
 406
 407                                 if (dr_out_buf) free(dr_out_buf);
 408                                 if (dr_in_buf)   free(dr_in_buf);
 409                                 if (dr_in_mask)  free(dr_in_mask);
 410
 411                                 dr_out_buf = malloc((xsdrsize + 7) / 8);
 412                                 dr_in_buf = malloc((xsdrsize + 7) / 8);
 413                                 dr_in_mask = malloc((xsdrsize + 7) / 8);
 414                         }
 415                         break;
 416
 417                 case XSDR:              /* these two are identical except for the dr_in_buf */
 418                 case XSDRTDO:
 419                         {
 420                                 int limit = xrepeat;
 421                                 int     matched = 0;
 422                                 int attempt;
 423
 424                                 const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
 425
 426                                 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
 427                                 {
 428                                         do_abort = 1;
 429                                         break;
 430                                 }
 431
 432                                 if (opcode == XSDRTDO)
 433                                 {
 434                                         if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf)  != ERROR_OK)
 435                                         {
 436                                                 do_abort = 1;
 437                                                 break;
 438                                         }
 439                                 }
 440
 441                                 if (limit < 1)
 442                                         limit = 1;
 443
 444                                 LOG_DEBUG("%s %d", op_name, xsdrsize);
 445
 446                                 for (attempt = 0; attempt < limit;  ++attempt)
 447                                 {
 448                                         struct scan_field field;
 449
 450                                         if (attempt > 0)
 451                                         {
 452                                                 /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
 453                                                    illustrated in psuedo code at end of this file.  We start from state
 454                                                    DRPAUSE:
 455                                                    go to Exit2-DR
 456                                                    go to Shift-DR
 457                                                    go to Exit1-DR
 458                                                    go to Update-DR
 459                                                    go to Run-Test/Idle
 460
 461                                                    This sequence should be harmless for other devices, and it
 462                                                    will be skipped entirely if xrepeat is set to zero.
 463                                                 */
 464
 465                                                 static tap_state_t exception_path[] = {
 466                                                         TAP_DREXIT2,
 467                                                         TAP_DRSHIFT,
 468                                                         TAP_DREXIT1,
 469                                                         TAP_DRUPDATE,
 470                                                         TAP_IDLE,
 471                                                 };
 472
 473                                                 jtag_add_pathmove(ARRAY_SIZE(exception_path), exception_path);
 474
 475                                                 if (verbose)
 476                                                         LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name, xsdrsize, attempt);
 477                                         }
 478
 479                                         field.num_bits = xsdrsize;
 480                                         field.out_value = dr_out_buf;
 481                                         field.in_value = calloc(DIV_ROUND_UP(field.num_bits, 8), 1);
 482
 483                                         if (tap == NULL)
 484                                                 jtag_add_plain_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 485                                         else
 486                                                 jtag_add_dr_scan(tap, 1, &field, jtag_set_end_state(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
 514                                         if (runtest_requires_tck)
 515                                                 jtag_add_clocks(xruntest);
 516                                         else
 517                                                 jtag_add_sleep(xruntest);
 518                                 }
 519                                 else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
 520                                         result = svf_add_statemove(xenddr);
 521                         }
 522                         break;
 523
 524                 case XSETSDRMASKS:
 525                         LOG_ERROR("unsupported XSETSDRMASKS\n");
 526                         unsupported = 1;
 527                         break;
 528
 529                 case XSDRINC:
 530                         LOG_ERROR("unsupported XSDRINC\n");
 531                         unsupported = 1;
 532                         break;
 533
 534                 case XSDRB:
 535                         LOG_ERROR("unsupported XSDRB\n");
 536                         unsupported = 1;
 537                         break;
 538
 539                 case XSDRC:
 540                         LOG_ERROR("unsupported XSDRC\n");
 541                         unsupported = 1;
 542                         break;
 543
 544                 case XSDRE:
 545                         LOG_ERROR("unsupported XSDRE\n");
 546                         unsupported = 1;
 547                         break;
 548
 549                 case XSDRTDOB:
 550                         LOG_ERROR("unsupported XSDRTDOB\n");
 551                         unsupported = 1;
 552                         break;
 553
 554                 case XSDRTDOC:
 555                         LOG_ERROR("unsupported XSDRTDOC\n");
 556                         unsupported = 1;
 557                         break;
 558
 559                 case XSDRTDOE:
 560                         LOG_ERROR("unsupported XSDRTDOE\n");
 561                         unsupported = 1;
 562                         break;
 563
 564                 case XSTATE:
 565                         {
 566                                 tap_state_t     mystate;
 567                                 uint8_t                 uc;
 568
 569                                 if (read(xsvf_fd, &uc, 1) < 0)
 570                                 {
 571                                         do_abort = 1;
 572                                         break;
 573                                 }
 574
 575                                 mystate = xsvf_to_tap(uc);
 576
 577                                 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate));
 578
 579                                 if (mystate == TAP_INVALID) {
 580                                         LOG_ERROR("XSVF: bad XSTATE %02x", uc);
 581                                         do_abort = 1;
 582                                         break;
 583                                 }
 584
 585                                 /* NOTE: the current state is SVF-stable! */
 586
 587                                 /* no change == NOP */
 588                                 if (mystate == cmd_queue_cur_state
 589                                                 && mystate != TAP_RESET)
 590                                         break;
 591
 592                                 /* Hand off to SVF? */
 593                                 if (svf_tap_state_is_stable(mystate))
 594                                 {
 595                                         result = svf_add_statemove(mystate);
 596                                         if (result != ERROR_OK)
 597                                                 unsupported = 1;
 598                                         break;
 599                                 }
 600
 601                                 /*
 602                                  * A sequence of XSTATE transitions, each TAP
 603                                  * state adjacent to the previous one.  Start
 604                                  * collecting them.
 605                                  */
 606                                 collecting_path = true;
 607                                 pathlen = 1;
 608                                 path[0] = mystate;
 609                         }
 610                         break;
 611
 612                 case XENDIR:
 613
 614                         if (read(xsvf_fd, &uc, 1) < 0)
 615                         {
 616                                 do_abort = 1;
 617                                 break;
 618                         }
 619
 620                         /* see page 22 of XSVF spec */
 621                         if (uc == 0)
 622                                 xendir = TAP_IDLE;
 623                         else if (uc == 1)
 624                                 xendir = TAP_IRPAUSE;
 625                         else
 626                         {
 627                                 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
 628                                 unsupported = 1;
 629                                 break;
 630                         }
 631
 632                         LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
 633                         break;
 634
 635                 case XENDDR:
 636
 637                         if (read(xsvf_fd, &uc, 1) < 0)
 638                         {
 639                                 do_abort = 1;
 640                                 break;
 641                         }
 642
 643                         /* see page 22 of XSVF spec */
 644                         if (uc == 0)
 645                                 xenddr = TAP_IDLE;
 646                         else if (uc == 1)
 647                                 xenddr = TAP_DRPAUSE;
 648                         else
 649                         {
 650                                 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
 651                                 unsupported = 1;
 652                                 break;
 653                         }
 654
 655                         LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
 656                         break;
 657
 658                 case XSIR:
 659                 case XSIR2:
 660                         {
 661                                 uint8_t short_buf[2];
 662                                 uint8_t*        ir_buf;
 663                                 int bitcount;
 664                                 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
 665
 666                                 if (opcode == XSIR)
 667                                 {
 668                                         /* one byte bitcount */
 669                                         if (read(xsvf_fd, short_buf, 1) < 0)
 670                                         {
 671                                                 do_abort = 1;
 672                                                 break;
 673                                         }
 674                                         bitcount = short_buf[0];
 675                                         LOG_DEBUG("XSIR %d", bitcount);
 676                                 }
 677                                 else
 678                                 {
 679                                         if (read(xsvf_fd, short_buf, 2) < 0)
 680                                         {
 681                                                 do_abort = 1;
 682                                                 break;
 683                                         }
 684                                         bitcount = be_to_h_u16(short_buf);
 685                                         LOG_DEBUG("XSIR2 %d", bitcount);
 686                                 }
 687
 688                                 ir_buf = malloc((bitcount + 7) / 8);
 689
 690                                 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
 691                                         do_abort = 1;
 692                                 else
 693                                 {
 694                                         struct scan_field field;
 695
 696                                         field.num_bits = bitcount;
 697                                         field.out_value = ir_buf;
 698
 699                                         field.in_value = NULL;
 700
 701
 702
 703
 704                                         if (tap == NULL)
 705                                                 jtag_add_plain_ir_scan(1, &field, my_end_state);
 706                                         else
 707                                                 jtag_add_ir_scan(tap, &field, my_end_state);
 708
 709                                         if (xruntest)
 710                                         {
 711                                                 if (runtest_requires_tck)
 712                                                         jtag_add_clocks(xruntest);
 713                                                 else
 714                                                         jtag_add_sleep(xruntest);
 715                                         }
 716
 717                                         /* Note that an -irmask of non-zero in your config file
 718                                          * can cause this to fail.  Setting -irmask to zero cand work
 719                                          * around the problem.
 720                                          */
 721
 722                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 723                                         result = jtag_execute_queue();
 724                                         if (result != ERROR_OK)
 725                                         {
 726                                                 tdo_mismatch = 1;
 727                                         }
 728                                 }
 729                                 free(ir_buf);
 730                         }
 731                         break;
 732
 733                 case XCOMMENT:
 734                         {
 735                                 unsigned int ndx = 0;
 736                                 char    comment[128];
 737
 738                                 do
 739                                 {
 740                                         if (read(xsvf_fd, &uc, 1) < 0)
 741                                         {
 742                                                 do_abort = 1;
 743                                                 break;
 744                                         }
 745
 746                                         if (ndx < sizeof(comment)-1)
 747                                                 comment[ndx++] = uc;
 748
 749                                 } while (uc != 0);
 750
 751                                 comment[sizeof(comment)-1] = 0;         /* regardless, terminate */
 752                                 if (verbose)
 753                                         LOG_USER("# %s", comment);
 754                         }
 755                         break;
 756
 757                 case XWAIT:
 758                         {
 759                                 /* expected in stream:
 760                                    XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
 761                                 */
 762
 763                                 uint8_t wait;
 764                                 uint8_t end;
 765                                 uint8_t delay_buf[4];
 766
 767                                 tap_state_t wait_state;
 768                                 tap_state_t end_state;
 769                                 int     delay;
 770
 771                                 if (read(xsvf_fd, &wait, 1) < 0
 772                                   || read(xsvf_fd, &end, 1) < 0
 773                                   || read(xsvf_fd, delay_buf, 4) < 0)
 774                                 {
 775                                         do_abort = 1;
 776                                         break;
 777                                 }
 778
 779                                 wait_state = xsvf_to_tap(wait);
 780                                 end_state  = xsvf_to_tap(end);
 781                                 delay      = be_to_h_u32(delay_buf);
 782
 783                                 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
 784
 785                                 if (runtest_requires_tck && wait_state == TAP_IDLE)
 786                                 {
 787                                         jtag_add_runtest(delay, end_state);
 788                                 }
 789                                 else
 790                                 {
 791                                         /* FIXME handle statemove errors ... */
 792                                         result = svf_add_statemove(wait_state);
 793                                         jtag_add_sleep(delay);
 794                                         result = svf_add_statemove(end_state);
 795                                 }
 796                         }
 797                         break;
 798
 799                 case XWAITSTATE:
 800                         {
 801                                 /* expected in stream:
 802                                    XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count> <uint32_t usecs>
 803                                 */
 804
 805                                 uint8_t  clock_buf[4];
 806                                 uint8_t usecs_buf[4];
 807                                 uint8_t wait;
 808                                 uint8_t end;
 809                                 tap_state_t wait_state;
 810                                 tap_state_t end_state;
 811                                 int clock_count;
 812                                 int usecs;
 813
 814                                 if (read(xsvf_fd, &wait, 1) < 0
 815                                  ||  read(xsvf_fd, &end, 1) < 0
 816                                  ||  read(xsvf_fd, clock_buf, 4) < 0
 817                                  ||  read(xsvf_fd, usecs_buf, 4) < 0)
 818                                 {
 819                                         do_abort = 1;
 820                                         break;
 821                                 }
 822
 823                                 wait_state = xsvf_to_tap(wait);
 824                                 end_state  = xsvf_to_tap(end);
 825
 826                                 clock_count = be_to_h_u32(clock_buf);
 827                                 usecs       = be_to_h_u32(usecs_buf);
 828
 829                                 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
 830                                         tap_state_name(wait_state),
 831                                         tap_state_name(end_state),
 832                                         clock_count, usecs);
 833
 834                                 /* the following states are 'stable', meaning that they have a transition
 835                                  * in the state diagram back to themselves.  This is necessary because we will
 836                                  * be issuing a number of clocks in this state.  This set of allowed states is also
 837                                  * determined by the SVF RUNTEST command's allowed states.
 838                                  */
 839                                 if (!svf_tap_state_is_stable(wait_state))
 840                                 {
 841                                         LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"",
 842                                                         tap_state_name(wait_state));
 843                                         unsupported = 1;
 844                                         /* REVISIT "break" so we won't run? */
 845                                 }
 846
 847                                 /* FIXME handle statemove errors ... */
 848                                 result = svf_add_statemove(wait_state);
 849
 850                                 jtag_add_clocks(clock_count);
 851
 852                                 jtag_add_sleep(usecs);
 853
 854                                 result = svf_add_statemove(end_state);
 855                         }
 856                         break;
 857
 858                 case LCOUNT:
 859                         {
 860                                 /* expected in stream:
 861                                    LCOUNT <uint32_t loop_count>
 862                                 */
 863                                 uint8_t  count_buf[4];
 864
 865                                 if (read(xsvf_fd, count_buf, 4) < 0)
 866                                 {
 867                                         do_abort = 1;
 868                                         break;
 869                                 }
 870
 871                                 loop_count = be_to_h_u32(count_buf);
 872                                 LOG_DEBUG("LCOUNT %d", loop_count);
 873                         }
 874                         break;
 875
 876                 case LDELAY:
 877                         {
 878                                 /* expected in stream:
 879                                    LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
 880                                 */
 881                                 uint8_t state;
 882                                 uint8_t  clock_buf[4];
 883                                 uint8_t  usecs_buf[4];
 884
 885                                 if (read(xsvf_fd, &state, 1) < 0
 886                                   || read(xsvf_fd, clock_buf, 4) < 0
 887                                   ||     read(xsvf_fd, usecs_buf, 4) < 0)
 888                                 {
 889                                         do_abort = 1;
 890                                         break;
 891                                 }
 892
 893                                 /* NOTE:  loop_state must be stable! */
 894                                 loop_state  = xsvf_to_tap(state);
 895                                 loop_clocks = be_to_h_u32(clock_buf);
 896                                 loop_usecs  = be_to_h_u32(usecs_buf);
 897
 898                                 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
 899                         }
 900                         break;
 901
 902                 /* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
 903                  * comes with clocks !AND! sleep requirements.
 904                  */
 905                 case LSDR:
 906                         {
 907                                 int limit = loop_count;
 908                                 int matched = 0;
 909                                 int attempt;
 910
 911                                 LOG_DEBUG("LSDR");
 912
 913                                 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
 914                                   || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK)
 915                                 {
 916                                         do_abort = 1;
 917                                         break;
 918                                 }
 919
 920                                 if (limit < 1)
 921                                         limit = 1;
 922
 923                                 for (attempt = 0; attempt < limit;  ++attempt)
 924                                 {
 925                                         struct scan_field field;
 926
 927                                         result = svf_add_statemove(loop_state);
 928                                         jtag_add_clocks(loop_clocks);
 929                                         jtag_add_sleep(loop_usecs);
 930
 931                                         field.num_bits = xsdrsize;
 932                                         field.out_value = dr_out_buf;
 933                                         field.in_value = calloc(DIV_ROUND_UP(field.num_bits, 8), 1);
 934
 935                                         if (attempt > 0 && verbose)
 936                                                 LOG_USER("LSDR retry %d", attempt);
 937
 938                                         if (tap == NULL)
 939                                                 jtag_add_plain_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 940                                         else
 941                                                 jtag_add_dr_scan(tap, 1, &field, jtag_set_end_state(TAP_DRPAUSE));
 942
 943                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 944
 945                                         free(field.in_value);
 946
 947
 948                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 949                                         result = jtag_execute_queue();
 950                                         if (result == ERROR_OK)
 951                                         {
 952                                                 matched = 1;
 953                                                 break;
 954                                         }
 955                                 }
 956
 957                                 if (!matched)
 958                                 {
 959                                         LOG_USER("LSDR mismatch");
 960                                         tdo_mismatch = 1;
 961                                         break;
 962                                 }
 963                         }
 964                         break;
 965
 966                 case XTRST:
 967                         {
 968                                 uint8_t trst_mode;
 969
 970                                 if (read(xsvf_fd, &trst_mode, 1) < 0)
 971                                 {
 972                                         do_abort = 1;
 973                                         break;
 974                                 }
 975
 976                                 switch (trst_mode)
 977                                 {
 978                                 case XTRST_ON:
 979                                         jtag_add_reset(1, 0);
 980                                         break;
 981                                 case XTRST_OFF:
 982                                 case XTRST_Z:
 983                                         jtag_add_reset(0, 0);
 984                                         break;
 985                                 case XTRST_ABSENT:
 986                                         break;
 987                                 default:
 988                                         LOG_ERROR("XTRST mode argument (0x%02X) out of range", trst_mode);
 989                                         do_abort = 1;
 990                                 }
 991                         }
 992                         break;
 993
 994                 default:
 995                         LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
 996                         unsupported = 1;
 997                 }
 998
 999                 if (do_abort || unsupported || tdo_mismatch)
1000                 {
1001                         LOG_DEBUG("xsvf failed, setting taps to reasonable state");
1002
1003                         /* upon error, return the TAPs to a reasonable state */
1004                         result = svf_add_statemove(TAP_IDLE);
1005                         result = jtag_execute_queue();
1006                         break;
1007                 }
1008         }
1009
1010         if (tdo_mismatch)
1011         {
1012                 command_print(CMD_CTX, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1013                                           file_offset);
1014
1015
1016                 return ERROR_FAIL;
1017         }
1018
1019         if (unsupported)
1020         {
1021                 off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
1022                 command_print(CMD_CTX,
1023                                 "unsupported xsvf command (0x%02X) at offset %jd, aborting",
1024                                 uc, (intmax_t)offset);
1025                 return ERROR_FAIL;
1026         }
1027
1028         if (do_abort)
1029         {
1030                 command_print(CMD_CTX, "premature end of xsvf file detected, aborting");
1031                 return ERROR_FAIL;
1032         }
1033
1034         if (dr_out_buf)
1035                 free(dr_out_buf);
1036
1037         if (dr_in_buf)
1038                 free(dr_in_buf);
1039
1040         if (dr_in_mask)
1041                 free(dr_in_mask);
1042
1043         close(xsvf_fd);
1044
1045         command_print(CMD_CTX, "XSVF file programmed successfully");
1046
1047         return ERROR_OK;
1048 }
1049
1050 static const struct command_registration xsvf_command_handlers[] = {
1051         {
1052                 .name = "xsvf",
1053                 .handler = handle_xsvf_command,
1054                 .mode = COMMAND_EXEC,
1055                 .help = "Runs a XSVF file.  If 'virt2' is given, xruntest "
1056                         "counts are interpreted as TCK cycles rather than "
1057                         "as microseconds.  Without the 'quiet' option, all "
1058                         "comments, retries, and mismatches will be reported.",
1059                 .usage = "(tapname|'plain') filename ['virt2'] ['quiet']",
1060         },
1061         COMMAND_REGISTRATION_DONE
1062 };
1063
1064 int xsvf_register_commands(struct command_context *cmd_ctx)
1065 {
1066         return register_commands(cmd_ctx, NULL, xsvf_command_handlers);
1067 }
1068
1069 #if 0   /* this comment style used to try and keep uncrustify from adding * at begin of line */
1070
1071 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
1072
1073 the following pseudo code clarifies the intent of the xrepeat support.  The
1074 flow given is for the entire processing of an SVF file, not an XSVF file.
1075 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1076
1077 "Pseudo-Code Algorithm for SVF-Based ISP"
1078
1079 1. Go to Test-Logic-Reset state
1080 2. Go to Run-Test Idle state
1081 3. Read SVF record
1082
1083 4. if SIR record then
1084            go to Shift-IR state
1085            Scan in <TDI value>
1086
1087 5. else if SDR record then
1088            set <repeat count> to 0
1089            store <TDI value> as <current TDI value>
1090            store <TDO value> as <current TDO value>
1091 6. go to Shift-DR state
1092            scan in <current TDI value>
1093            if <current TDO value> is specified then
1094                    if <current TDO value> does not equal <actual TDO value> then
1095                            if <repeat count> > 32 then
1096                                    LOG ERROR
1097                                    go to Run-Test Idle state
1098                                    go to Step 3
1099                            end if
1100                            go to Pause-DR
1101                            go to Exit2-DR
1102                            go to Shift-DR
1103                            go to Exit1-DR
1104                            go to Update-DR
1105                            go to Run-Test/Idle
1106                            increment <repeat count> by 1
1107                            pause <current pause time> microseconds
1108                            go to Step 6)
1109                    end if
1110            else
1111                    go to Run-Test Idle state
1112                    go to Step 3
1113            endif
1114 else if RUNTEST record then
1115    pause tester for <TCK value> microseconds
1116    store <TCK value> as <current pause time>
1117 end if
1118
1119 #endif