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