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