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