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                                             *
  26  *       Free Software Foundation, Inc.,                                                                                   *
  27  *       59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.                         *
  28  ***************************************************************************/
  29
  30
  31 /* The specification for SVF is available here:
  32  * http://www.asset-intertech.com/support/svf.pdf
  33  * Below, this document is refered to as the "SVF spec".
  34  *
  35  * The specification for XSVF is available here:
  36  * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
  37  * Below, this document is refered to as the "XSVF spec".
  38  */
  39
  40 #ifdef HAVE_CONFIG_H
  41 #include "config.h"
  42 #endif
  43
  44 #include "xsvf.h"
  45 #include "jtag.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 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 127
 128 static int xsvf_fd = 0;
 129
 130
 131 /* map xsvf tap state to an openocd "tap_state_t" */
 132 static tap_state_t xsvf_to_tap( int xsvf_state )
 133 {
 134         tap_state_t     ret;
 135
 136         switch ( xsvf_state )
 137         {
 138         case XSV_RESET:                 ret = TAP_RESET;                        break;
 139         case XSV_IDLE:                  ret = TAP_IDLE;                 break;
 140         case XSV_DRSELECT:              ret = TAP_DRSELECT;             break;
 141         case XSV_DRCAPTURE:             ret = TAP_DRCAPTURE;            break;
 142         case XSV_DRSHIFT:               ret = TAP_DRSHIFT;              break;
 143         case XSV_DREXIT1:               ret = TAP_DREXIT1;              break;
 144         case XSV_DRPAUSE:               ret = TAP_DRPAUSE;              break;
 145         case XSV_DREXIT2:               ret = TAP_DREXIT2;              break;
 146         case XSV_DRUPDATE:              ret = TAP_DRUPDATE;             break;
 147         case XSV_IRSELECT:              ret = TAP_IRSELECT;             break;
 148         case XSV_IRCAPTURE:             ret = TAP_IRCAPTURE;            break;
 149         case XSV_IRSHIFT:               ret = TAP_IRSHIFT;              break;
 150         case XSV_IREXIT1:               ret = TAP_IREXIT1;              break;
 151         case XSV_IRPAUSE:               ret = TAP_IRPAUSE;              break;
 152         case XSV_IREXIT2:               ret = TAP_IREXIT2;              break;
 153         case XSV_IRUPDATE:              ret = TAP_IRUPDATE;             break;
 154         default:
 155                 LOG_ERROR( "UNKNOWN XSVF STATE 0x%02X", xsvf_state );
 156                 exit(1);
 157         }
 158
 159         return ret;
 160 }
 161
 162
 163
 164 int xsvf_register_commands(struct command_context_s *cmd_ctx)
 165 {
 166         register_command(cmd_ctx, NULL, "xsvf", handle_xsvf_command,
 167                 COMMAND_EXEC, "run xsvf <file> [virt2] [quiet]");
 168
 169         return ERROR_OK;
 170 }
 171
 172 static int xsvf_read_buffer(int num_bits, int fd, uint8_t* buf)
 173 {
 174         int num_bytes;
 175
 176         for (num_bytes = (num_bits + 7) / 8; num_bytes > 0; num_bytes--)
 177         {
 178                 /* reverse the order of bytes as they are read sequentially from file */
 179                 if (read(fd, buf + num_bytes - 1, 1) < 0)
 180                         return ERROR_XSVF_EOF;
 181         }
 182
 183         return ERROR_OK;
 184 }
 185
 186
 187 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 188 {
 189         uint8_t *dr_out_buf = NULL;                             /* from host to device (TDI) */
 190         uint8_t *dr_in_buf = NULL;                              /* from device to host (TDO) */
 191         uint8_t *dr_in_mask = NULL;
 192
 193         int xsdrsize = 0;
 194         int xruntest = 0;                                       /* number of TCK cycles OR microseconds */
 195         int xrepeat      = 0;                                   /* number of retries */
 196
 197         tap_state_t     xendir = TAP_IDLE;              /* see page 8 of the SVF spec, initial xendir to be TAP_IDLE */
 198         tap_state_t xenddr = TAP_IDLE;
 199
 200         uint8_t                 opcode;
 201         uint8_t         uc;
 202         long            file_offset = 0;
 203
 204         int             loop_count = 0;
 205         tap_state_t     loop_state = TAP_IDLE;
 206         int             loop_clocks = 0;
 207         int             loop_usecs = 0;
 208
 209         int             do_abort = 0;
 210         int             unsupported = 0;
 211         int             tdo_mismatch = 0;
 212         int             result;
 213         int             verbose = 1;
 214         char*   filename;
 215
 216         int             runtest_requires_tck = 0;       /* a flag telling whether to clock TCK during waits, or simply sleep, controled by virt2 */
 217
 218
 219         /* use NULL to indicate a "plain" xsvf file which accounts for
 220            additional devices in the scan chain, otherwise the device
 221            that should be affected
 222         */
 223         jtag_tap_t *tap = NULL;
 224
 225         if (argc < 2)
 226         {
 227                 command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
 228                 return ERROR_FAIL;
 229         }
 230
 231         filename = args[1];             /* we mess with args starting point below, snapshot filename here */
 232
 233         if (strcmp(args[0], "plain") != 0)
 234         {
 235                 tap = jtag_tap_by_string( args[0] );
 236                 if (!tap )
 237                 {
 238                         command_print( cmd_ctx, "Tap: %s unknown", args[0] );
 239                         return ERROR_FAIL;
 240                 }
 241         }
 242
 243         if ((xsvf_fd = open(filename, O_RDONLY)) < 0)
 244         {
 245                 command_print(cmd_ctx, "file \"%s\" not found", filename);
 246                 return ERROR_FAIL;
 247         }
 248
 249         /* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
 250         if ((argc > 2) && (strcmp(args[2], "virt2") == 0))
 251         {
 252                 runtest_requires_tck = 1;
 253                 --argc;
 254                 ++args;
 255         }
 256
 257         if ((argc > 2) && (strcmp(args[2], "quiet") == 0))
 258         {
 259                 verbose = 0;
 260         }
 261
 262         LOG_USER("xsvf processing file: \"%s\"", filename);
 263
 264         while ( read(xsvf_fd, &opcode, 1) > 0 )
 265         {
 266                 /* record the position of the just read opcode within the file */
 267                 file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
 268
 269                 switch (opcode)
 270                 {
 271                 case XCOMPLETE:
 272                         LOG_DEBUG("XCOMPLETE");
 273
 274                         result = jtag_execute_queue();
 275                         if (result != ERROR_OK)
 276                         {
 277                                 tdo_mismatch = 1;
 278                                 break;
 279                         }
 280                         break;
 281
 282                 case XTDOMASK:
 283                         LOG_DEBUG("XTDOMASK");
 284                         if (dr_in_mask && (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
 285                                 do_abort = 1;
 286                         break;
 287
 288                 case XRUNTEST:
 289                         {
 290                                 uint8_t xruntest_buf[4];
 291
 292                                 if (read(xsvf_fd, xruntest_buf, 4) < 0)
 293                                 {
 294                                         do_abort = 1;
 295                                         break;
 296                                 }
 297
 298                                 xruntest = be_to_h_u32(xruntest_buf);
 299                                 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
 300                         }
 301                         break;
 302
 303                 case XREPEAT:
 304                         {
 305                                 uint8_t myrepeat;
 306
 307                                 if (read(xsvf_fd, &myrepeat, 1) < 0)
 308                                         do_abort = 1;
 309                                 else
 310                                 {
 311                                         xrepeat = myrepeat;
 312                                         LOG_DEBUG("XREPEAT %d", xrepeat );
 313                                 }
 314                         }
 315                         break;
 316
 317                 case XSDRSIZE:
 318                         {
 319                                 uint8_t xsdrsize_buf[4];
 320
 321                                 if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
 322                                 {
 323                                         do_abort = 1;
 324                                         break;
 325                                 }
 326
 327                                 xsdrsize = be_to_h_u32(xsdrsize_buf);
 328                                 LOG_DEBUG("XSDRSIZE %d", xsdrsize);
 329
 330                                 if ( dr_out_buf ) free(dr_out_buf);
 331                                 if ( dr_in_buf)   free(dr_in_buf);
 332                                 if ( dr_in_mask)  free(dr_in_mask);
 333
 334                                 dr_out_buf = malloc((xsdrsize + 7) / 8);
 335                                 dr_in_buf = malloc((xsdrsize + 7) / 8);
 336                                 dr_in_mask = malloc((xsdrsize + 7) / 8);
 337                         }
 338                         break;
 339
 340                 case XSDR:              /* these two are identical except for the dr_in_buf */
 341                 case XSDRTDO:
 342                         {
 343                                 int limit = xrepeat;
 344                                 int     matched = 0;
 345                                 int attempt;
 346
 347                                 const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
 348
 349                                 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
 350                                 {
 351                                         do_abort = 1;
 352                                         break;
 353                                 }
 354
 355                                 if (opcode == XSDRTDO)
 356                                 {
 357                                         if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf)  != ERROR_OK )
 358                                         {
 359                                                 do_abort = 1;
 360                                                 break;
 361                                         }
 362                                 }
 363
 364                                 if (limit < 1)
 365                                         limit = 1;
 366
 367                                 LOG_DEBUG("%s %d", op_name, xsdrsize);
 368
 369                                 for ( attempt = 0; attempt < limit;  ++attempt )
 370                                 {
 371                                         scan_field_t field;
 372
 373                                         if ( attempt > 0 )
 374                                         {
 375                                                 /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
 376                                                    illustrated in psuedo code at end of this file.  We start from state
 377                                                    DRPAUSE:
 378                                                    go to Exit2-DR
 379                                                    go to Shift-DR
 380                                                    go to Exit1-DR
 381                                                    go to Update-DR
 382                                                    go to Run-Test/Idle
 383
 384                                                    This sequence should be harmless for other devices, and it
 385                                                    will be skipped entirely if xrepeat is set to zero.
 386                                                 */
 387
 388                                                 static tap_state_t exception_path[] = {
 389                                                         TAP_DREXIT2,
 390                                                         TAP_DRSHIFT,
 391                                                         TAP_DREXIT1,
 392                                                         TAP_DRUPDATE,
 393                                                         TAP_IDLE,
 394                                                 };
 395
 396                                                 jtag_add_pathmove( DIM(exception_path), exception_path );
 397
 398                                                 if (verbose)
 399                                                         LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name, xsdrsize, attempt);
 400                                         }
 401
 402                                         field.tap = tap;
 403                                         field.num_bits = xsdrsize;
 404                                         field.out_value = dr_out_buf;
 405                                         field.in_value = calloc(CEIL(field.num_bits, 8), 1);
 406
 407                                         if (tap == NULL)
 408                                                 jtag_add_plain_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 409                                         else
 410                                                 jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 411
 412                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 413
 414                                         free(field.in_value);
 415
 416
 417                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 418                                         result = jtag_execute_queue();
 419                                         if (result == ERROR_OK)
 420                                         {
 421                                                 matched = 1;
 422                                                 break;
 423                                         }
 424                                 }
 425
 426                                 if (!matched)
 427                                 {
 428                                         LOG_USER( "%s mismatch", op_name);
 429                                         tdo_mismatch = 1;
 430                                         break;
 431                                 }
 432
 433                                 /* See page 19 of XSVF spec regarding opcode "XSDR" */
 434                                 if (xruntest)
 435                                 {
 436                                         jtag_add_statemove(TAP_IDLE);
 437
 438                                         if (runtest_requires_tck)
 439                                                 jtag_add_clocks(xruntest);
 440                                         else
 441                                                 jtag_add_sleep(xruntest);
 442                                 }
 443                                 else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
 444                                         jtag_add_statemove(xenddr);
 445                         }
 446                         break;
 447
 448                 case XSETSDRMASKS:
 449                         LOG_ERROR("unsupported XSETSDRMASKS\n");
 450                         unsupported = 1;
 451                         break;
 452
 453                 case XSDRINC:
 454                         LOG_ERROR("unsupported XSDRINC\n");
 455                         unsupported = 1;
 456                         break;
 457
 458                 case XSDRB:
 459                         LOG_ERROR("unsupported XSDRB\n");
 460                         unsupported = 1;
 461                         break;
 462
 463                 case XSDRC:
 464                         LOG_ERROR("unsupported XSDRC\n");
 465                         unsupported = 1;
 466                         break;
 467
 468                 case XSDRE:
 469                         LOG_ERROR("unsupported XSDRE\n");
 470                         unsupported = 1;
 471                         break;
 472
 473                 case XSDRTDOB:
 474                         LOG_ERROR("unsupported XSDRTDOB\n");
 475                         unsupported = 1;
 476                         break;
 477
 478                 case XSDRTDOC:
 479                         LOG_ERROR("unsupported XSDRTDOC\n");
 480                         unsupported = 1;
 481                         break;
 482
 483                 case XSDRTDOE:
 484                         LOG_ERROR("unsupported XSDRTDOE\n");
 485                         unsupported = 1;
 486                         break;
 487
 488                 case XSTATE:
 489                         {
 490                                 tap_state_t     mystate;
 491                                 uint8_t                 uc;
 492
 493                                 if (read(xsvf_fd, &uc, 1) < 0)
 494                                 {
 495                                         do_abort = 1;
 496                                         break;
 497                                 }
 498
 499                                 mystate = xsvf_to_tap(uc);
 500
 501                                 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate) );
 502
 503                                 /*      there is no need for the lookahead code that was here since we
 504                                         queue up the jtag commands anyway.  This is a simple way to handle
 505                                         the XSTATE.
 506                                 */
 507
 508                                 if ( jtag_add_statemove( mystate ) != ERROR_OK )
 509                                 {
 510                                         /*      For special states known as stable states
 511                                                 (Test-Logic-Reset, Run-Test/Idle, Pause-DR, Pause- IR),
 512                                                 an XSVF interpreter follows predefined TAP state paths
 513                                                 when the starting state is a stable state and when the
 514                                                 XSTATE specifies a new stable state (see the STATE
 515                                                 command in the [Ref 5] for the TAP state paths between
 516                                                 stable states). For non-stable states, XSTATE should
 517                                                 specify a state that is only one TAP state transition
 518                                                 distance from the current TAP state to avoid undefined
 519                                                 TAP state paths. A sequence of multiple XSTATE commands
 520                                                 can be issued to transition the TAP through a specific
 521                                                 state path.
 522                                         */
 523
 524                                         LOG_ERROR("XSTATE %s is not reachable from current state %s in one clock cycle",
 525                                                 tap_state_name(mystate),
 526                                                 tap_state_name(cmd_queue_cur_state)
 527                                                 );
 528                                 }
 529                         }
 530                         break;
 531
 532                 case XENDIR:
 533
 534                         if (read(xsvf_fd, &uc, 1) < 0)
 535                         {
 536                                 do_abort = 1;
 537                                 break;
 538                         }
 539
 540                         /* see page 22 of XSVF spec */
 541                         if ( uc == 0 )
 542                                 xendir = TAP_IDLE;
 543                         else if ( uc == 1 )
 544                                 xendir = TAP_IRPAUSE;
 545                         else
 546                         {
 547                                 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
 548                                 unsupported = 1;
 549                                 break;
 550                         }
 551
 552                         LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
 553                         break;
 554
 555                 case XENDDR:
 556
 557                         if (read(xsvf_fd, &uc, 1) < 0)
 558                         {
 559                                 do_abort = 1;
 560                                 break;
 561                         }
 562
 563                         /* see page 22 of XSVF spec */
 564                         if ( uc == 0 )
 565                                 xenddr = TAP_IDLE;
 566                         else if ( uc == 1 )
 567                                 xenddr = TAP_DRPAUSE;
 568                         else
 569                         {
 570                                 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
 571                                 unsupported = 1;
 572                                 break;
 573                         }
 574
 575                         LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
 576                         break;
 577
 578                 case XSIR:
 579                 case XSIR2:
 580                         {
 581                                 uint8_t short_buf[2];
 582                                 uint8_t*        ir_buf;
 583                                 int bitcount;
 584                                 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
 585
 586                                 if ( opcode == XSIR )
 587                                 {
 588                                         /* one byte bitcount */
 589                                         if (read(xsvf_fd, short_buf, 1) < 0)
 590                                         {
 591                                                 do_abort = 1;
 592                                                 break;
 593                                         }
 594                                         bitcount = short_buf[0];
 595                                         LOG_DEBUG("XSIR %d", bitcount);
 596                                 }
 597                                 else
 598                                 {
 599                                         if (read(xsvf_fd, short_buf, 2) < 0)
 600                                         {
 601                                                 do_abort = 1;
 602                                                 break;
 603                                         }
 604                                         bitcount = be_to_h_u16(short_buf);
 605                                         LOG_DEBUG("XSIR2 %d", bitcount);
 606                                 }
 607
 608                                 ir_buf = malloc((bitcount + 7) / 8);
 609
 610                                 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
 611                                         do_abort = 1;
 612                                 else
 613                                 {
 614                                         scan_field_t field;
 615
 616                                         field.tap = tap;
 617                                         field.num_bits = bitcount;
 618                                         field.out_value = ir_buf;
 619
 620                                         field.in_value = NULL;
 621
 622
 623
 624
 625                                         if (tap == NULL)
 626                                                 jtag_add_plain_ir_scan(1, &field, my_end_state);
 627                                         else
 628                                                 jtag_add_ir_scan(1, &field, my_end_state);
 629
 630                                         if (xruntest)
 631                                         {
 632                                                 if (runtest_requires_tck)
 633                                                         jtag_add_clocks(xruntest);
 634                                                 else
 635                                                         jtag_add_sleep(xruntest);
 636                                         }
 637
 638                                         /* Note that an -irmask of non-zero in your config file
 639                                          * can cause this to fail.  Setting -irmask to zero cand work
 640                                          * around the problem.
 641                                          */
 642
 643                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 644                                         result = jtag_execute_queue();
 645                                         if (result != ERROR_OK)
 646                                         {
 647                                                 tdo_mismatch = 1;
 648                                         }
 649                                 }
 650                                 free(ir_buf);
 651                         }
 652                         break;
 653
 654                 case XCOMMENT:
 655                         {
 656                                 unsigned int ndx = 0;
 657                                 char    comment[128];
 658
 659                                 do
 660                                 {
 661                                         if (read(xsvf_fd, &uc, 1) < 0)
 662                                         {
 663                                                 do_abort = 1;
 664                                                 break;
 665                                         }
 666
 667                                         if ( ndx < sizeof(comment)-1 )
 668                                                 comment[ndx++] = uc;
 669
 670                                 } while (uc != 0);
 671
 672                                 comment[sizeof(comment)-1] = 0;         /* regardless, terminate */
 673                                 if (verbose)
 674                                         LOG_USER("# %s", comment);
 675                         }
 676                         break;
 677
 678                 case XWAIT:
 679                         {
 680                                 /* expected in stream:
 681                                    XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
 682                                 */
 683
 684                                 uint8_t wait;
 685                                 uint8_t end;
 686                                 uint8_t delay_buf[4];
 687
 688                                 tap_state_t wait_state;
 689                                 tap_state_t end_state;
 690                                 int     delay;
 691
 692                                 if ( read(xsvf_fd, &wait, 1) < 0
 693                                   || read(xsvf_fd, &end, 1) < 0
 694                                   || read(xsvf_fd, delay_buf, 4) < 0)
 695                                 {
 696                                         do_abort = 1;
 697                                         break;
 698                                 }
 699
 700                                 wait_state = xsvf_to_tap(wait);
 701                                 end_state  = xsvf_to_tap(end);
 702                                 delay      = be_to_h_u32(delay_buf);
 703
 704                                 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
 705
 706                                 if (runtest_requires_tck && wait_state == TAP_IDLE )
 707                                 {
 708                                         jtag_add_runtest(delay, end_state);
 709                                 }
 710                                 else
 711                                 {
 712                                         jtag_add_statemove( wait_state );
 713                                         jtag_add_sleep(delay);
 714                                         jtag_add_statemove( end_state );
 715                                 }
 716                         }
 717                         break;
 718
 719                 case XWAITSTATE:
 720                         {
 721                                 /* expected in stream:
 722                                    XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count> <uint32_t usecs>
 723                                 */
 724
 725                                 uint8_t  clock_buf[4];
 726                                 uint8_t         usecs_buf[4];
 727                                 uint8_t wait;
 728                                 uint8_t end;
 729                                 tap_state_t wait_state;
 730                                 tap_state_t end_state;
 731                                 int clock_count;
 732                                 int usecs;
 733
 734                                 if ( read(xsvf_fd, &wait, 1) < 0
 735                                  ||  read(xsvf_fd, &end, 1) < 0
 736                                  ||  read(xsvf_fd, clock_buf, 4) < 0
 737                                  ||  read(xsvf_fd, usecs_buf, 4) < 0 )
 738                                 {
 739                                         do_abort = 1;
 740                                         break;
 741                                 }
 742
 743                                 wait_state = xsvf_to_tap( wait );
 744                                 end_state  = xsvf_to_tap( end );
 745
 746                                 clock_count = be_to_h_u32(clock_buf);
 747                                 usecs       = be_to_h_u32(usecs_buf);
 748
 749                                 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
 750                                         tap_state_name(wait_state),
 751                                         tap_state_name(end_state),
 752                                         clock_count, usecs);
 753
 754                                 /* the following states are 'stable', meaning that they have a transition
 755                                  * in the state diagram back to themselves.  This is necessary because we will
 756                                  * be issuing a number of clocks in this state.  This set of allowed states is also
 757                                  * determined by the SVF RUNTEST command's allowed states.
 758                                  */
 759                                 if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE)
 760                                 {
 761                                         LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state ));
 762                                         unsupported = 1;
 763                                 }
 764
 765                                 jtag_add_statemove( wait_state );
 766
 767                                 jtag_add_clocks( clock_count );
 768
 769                                 jtag_add_sleep( usecs );
 770
 771                                 jtag_add_statemove( end_state );
 772                         }
 773                         break;
 774
 775                 case LCOUNT:
 776                         {
 777                                 /* expected in stream:
 778                                    LCOUNT <uint32_t loop_count>
 779                                 */
 780                                 uint8_t  count_buf[4];
 781
 782                                 if ( read(xsvf_fd, count_buf, 4) < 0 )
 783                                 {
 784                                         do_abort = 1;
 785                                         break;
 786                                 }
 787
 788                                 loop_count = be_to_h_u32(count_buf);
 789                                 LOG_DEBUG("LCOUNT %d", loop_count);
 790                         }
 791                         break;
 792
 793                 case LDELAY:
 794                         {
 795                                 /* expected in stream:
 796                                    LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
 797                                 */
 798                                 uint8_t state;
 799                                 uint8_t  clock_buf[4];
 800                                 uint8_t  usecs_buf[4];
 801
 802                                 if ( read(xsvf_fd, &state, 1) < 0
 803                                   || read(xsvf_fd, clock_buf, 4) < 0
 804                                   ||     read(xsvf_fd, usecs_buf, 4) < 0 )
 805                                 {
 806                                         do_abort = 1;
 807                                         break;
 808                                 }
 809
 810                                 loop_state  = xsvf_to_tap(state);
 811                                 loop_clocks = be_to_h_u32(clock_buf);
 812                                 loop_usecs  = be_to_h_u32(usecs_buf);
 813
 814                                 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
 815                         }
 816                         break;
 817
 818                 /* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
 819                  * comes with clocks !AND! sleep requirements.
 820                  */
 821                 case LSDR:
 822                         {
 823                                 int limit = loop_count;
 824                                 int matched = 0;
 825                                 int attempt;
 826
 827                                 LOG_DEBUG("LSDR");
 828
 829                                 if ( xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
 830                                   || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
 831                                 {
 832                                         do_abort = 1;
 833                                         break;
 834                                 }
 835
 836                                 if (limit < 1)
 837                                         limit = 1;
 838
 839                                 for ( attempt = 0; attempt < limit;  ++attempt )
 840                                 {
 841                                         scan_field_t field;
 842
 843                                         jtag_add_statemove( loop_state );
 844                                         jtag_add_clocks(loop_clocks);
 845                                         jtag_add_sleep(loop_usecs);
 846
 847                                         field.tap = tap;
 848                                         field.num_bits = xsdrsize;
 849                                         field.out_value = dr_out_buf;
 850                                         field.in_value = calloc(CEIL(field.num_bits, 8), 1);
 851
 852                                         if (attempt > 0 && verbose)
 853                                                 LOG_USER("LSDR retry %d", attempt);
 854
 855                                         if (tap == NULL)
 856                                                 jtag_add_plain_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 857                                         else
 858                                                 jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 859
 860                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 861
 862                                         free(field.in_value);
 863
 864
 865                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 866                                         result = jtag_execute_queue();
 867                                         if (result == ERROR_OK)
 868                                         {
 869                                                 matched = 1;
 870                                                 break;
 871                                         }
 872                                 }
 873
 874                                 if (!matched )
 875                                 {
 876                                         LOG_USER( "LSDR mismatch" );
 877                                         tdo_mismatch = 1;
 878                                         break;
 879                                 }
 880                         }
 881                         break;
 882
 883                 case XTRST:
 884                         {
 885                                 uint8_t trst_mode;
 886
 887                                 if (read(xsvf_fd, &trst_mode, 1) < 0)
 888                                 {
 889                                         do_abort = 1;
 890                                         break;
 891                                 }
 892
 893                                 switch ( trst_mode )
 894                                 {
 895                                 case XTRST_ON:
 896                                         jtag_add_reset(1, 0);
 897                                         break;
 898                                 case XTRST_OFF:
 899                                 case XTRST_Z:
 900                                         jtag_add_reset(0, 0);
 901                                         break;
 902                                 case XTRST_ABSENT:
 903                                         break;
 904                                 default:
 905                                         LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode );
 906                                         do_abort = 1;
 907                                 }
 908                         }
 909                         break;
 910
 911                 default:
 912                         LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
 913                         unsupported = 1;
 914                 }
 915
 916                 if (do_abort || unsupported || tdo_mismatch)
 917                 {
 918                         LOG_DEBUG("xsvf failed, setting taps to reasonable state");
 919
 920                         /* upon error, return the TAPs to a reasonable state */
 921                         jtag_add_statemove( TAP_IDLE );
 922                         jtag_execute_queue();
 923                         break;
 924                 }
 925         }
 926
 927         if (tdo_mismatch)
 928         {
 929                 command_print(cmd_ctx, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
 930                                           file_offset );
 931
 932
 933                 return ERROR_FAIL;
 934         }
 935
 936         if (unsupported)
 937         {
 938                 off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
 939                 command_print(cmd_ctx,
 940                                 "unsupported xsvf command (0x%02X) at offset %jd, aborting",
 941                                 uc, (intmax_t)offset);
 942                 return ERROR_FAIL;
 943         }
 944
 945         if (do_abort)
 946         {
 947                 command_print(cmd_ctx, "premature end of xsvf file detected, aborting");
 948                 return ERROR_FAIL;
 949         }
 950
 951         if (dr_out_buf)
 952                 free(dr_out_buf);
 953
 954         if (dr_in_buf)
 955                 free(dr_in_buf);
 956
 957         if (dr_in_mask)
 958                 free(dr_in_mask);
 959
 960         close(xsvf_fd);
 961
 962         command_print(cmd_ctx, "XSVF file programmed successfully");
 963
 964         return ERROR_OK;
 965 }
 966
 967
 968 #if 0   /* this comment style used to try and keep uncrustify from adding * at begin of line */
 969
 970 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
 971
 972 the following pseudo code clarifies the intent of the xrepeat support.  The
 973 flow given is for the entire processing of an SVF file, not an XSVF file.
 974 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
 975
 976 "Pseudo-Code Algorithm for SVF-Based ISP"
 977
 978 1. Go to Test-Logic-Reset state
 979 2. Go to Run-Test Idle state
 980 3. Read SVF record
 981
 982 4. if SIR record then
 983            go to Shift-IR state
 984            Scan in <TDI value>
 985
 986 5. else if SDR record then
 987            set <repeat count> to 0
 988            store <TDI value> as <current TDI value>
 989            store <TDO value> as <current TDO value>
 990 6. go to Shift-DR state
 991            scan in <current TDI value>
 992            if <current TDO value> is specified then
 993                    if <current TDO value> does not equal <actual TDO value> then
 994                            if <repeat count> > 32 then
 995                                    LOG ERROR
 996                                    go to Run-Test Idle state
 997                                    go to Step 3
 998                            end if
 999                            go to Pause-DR
1000                            go to Exit2-DR
1001                            go to Shift-DR
1002                            go to Exit1-DR
1003                            go to Update-DR
1004                            go to Run-Test/Idle
1005                            increment <repeat count> by 1
1006                            pause <current pause time> microseconds
1007                            go to Step 6)
1008                    end if
1009            else
1010                    go to Run-Test Idle state
1011                    go to Step 3
1012            endif
1013 else if RUNTEST record then
1014    pause tester for <TCK value> microseconds
1015    store <TCK value> as <current pause time>
1016 end if
1017
1018 #endif