git.sur5r.net Git - 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                                         field.in_value = calloc(CEIL(field.num_bits, 8), 1);
 505
 506                                         if (tap == NULL)
 507                                                 jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
 508                                         else
 509                                                 jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
 510
 511                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 512
 513                                         free(field.in_value);
 514
 515
 516                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 517                                         result = jtag_execute_queue();
 518                                         if (result == ERROR_OK)
 519                                         {
 520                                                 matched = 1;
 521                                                 break;
 522                                         }
 523                                 }
 524
 525                                 if (!matched)
 526                                 {
 527                                         LOG_USER( "%s mismatch", op_name);
 528                                         tdo_mismatch = 1;
 529                                         break;
 530                                 }
 531
 532                                 /* See page 19 of XSVF spec regarding opcode "XSDR" */
 533                                 if (xruntest)
 534                                 {
 535                                         xsvf_add_statemove(TAP_IDLE);
 536
 537                                         if (runtest_requires_tck)
 538                                                 jtag_add_clocks(xruntest);
 539                                         else
 540                                                 jtag_add_sleep(xruntest);
 541                                 }
 542                                 else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
 543                                         xsvf_add_statemove(xenddr);
 544                         }
 545                         break;
 546
 547                 case XSETSDRMASKS:
 548                         LOG_ERROR("unsupported XSETSDRMASKS\n");
 549                         unsupported = 1;
 550                         break;
 551
 552                 case XSDRINC:
 553                         LOG_ERROR("unsupported XSDRINC\n");
 554                         unsupported = 1;
 555                         break;
 556
 557                 case XSDRB:
 558                         LOG_ERROR("unsupported XSDRB\n");
 559                         unsupported = 1;
 560                         break;
 561
 562                 case XSDRC:
 563                         LOG_ERROR("unsupported XSDRC\n");
 564                         unsupported = 1;
 565                         break;
 566
 567                 case XSDRE:
 568                         LOG_ERROR("unsupported XSDRE\n");
 569                         unsupported = 1;
 570                         break;
 571
 572                 case XSDRTDOB:
 573                         LOG_ERROR("unsupported XSDRTDOB\n");
 574                         unsupported = 1;
 575                         break;
 576
 577                 case XSDRTDOC:
 578                         LOG_ERROR("unsupported XSDRTDOC\n");
 579                         unsupported = 1;
 580                         break;
 581
 582                 case XSDRTDOE:
 583                         LOG_ERROR("unsupported XSDRTDOE\n");
 584                         unsupported = 1;
 585                         break;
 586
 587                 case XSTATE:
 588                         {
 589                                 tap_state_t     mystate;
 590                                 u8                      uc;
 591
 592                                 if (read(xsvf_fd, &uc, 1) < 0)
 593                                 {
 594                                         do_abort = 1;
 595                                         break;
 596                                 }
 597
 598                                 mystate = xsvf_to_tap(uc);
 599
 600                                 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate) );
 601
 602                                 /*      there is no need for the lookahead code that was here since we
 603                                         queue up the jtag commands anyway.  This is a simple way to handle
 604                                         the XSTATE.
 605                                 */
 606
 607                                 if( xsvf_add_statemove( mystate ) != ERROR_OK )
 608                                 {
 609                                         /*      For special states known as stable states
 610                                                 (Test-Logic-Reset, Run-Test/Idle, Pause-DR, Pause- IR),
 611                                                 an XSVF interpreter follows predefined TAP state paths
 612                                                 when the starting state is a stable state and when the
 613                                                 XSTATE specifies a new stable state (see the STATE
 614                                                 command in the [Ref 5] for the TAP state paths between
 615                                                 stable states). For non-stable states, XSTATE should
 616                                                 specify a state that is only one TAP state transition
 617                                                 distance from the current TAP state to avoid undefined
 618                                                 TAP state paths. A sequence of multiple XSTATE commands
 619                                                 can be issued to transition the TAP through a specific
 620                                                 state path.
 621                                         */
 622
 623                                         LOG_ERROR("XSTATE %s is not reachable from current state %s in one clock cycle",
 624                                                 tap_state_name(mystate),
 625                                                 tap_state_name(cmd_queue_cur_state)
 626                                                 );
 627                                 }
 628                         }
 629                         break;
 630
 631                 case XENDIR:
 632
 633                         if (read(xsvf_fd, &uc, 1) < 0)
 634                         {
 635                                 do_abort = 1;
 636                                 break;
 637                         }
 638
 639                         /* see page 22 of XSVF spec */
 640                         if( uc == 0 )
 641                                 xendir = TAP_IDLE;
 642                         else if( uc == 1 )
 643                                 xendir = TAP_IRPAUSE;
 644                         else
 645                         {
 646                                 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
 647                                 unsupported = 1;
 648                                 break;
 649                         }
 650
 651                         LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
 652                         break;
 653
 654                 case XENDDR:
 655
 656                         if (read(xsvf_fd, &uc, 1) < 0)
 657                         {
 658                                 do_abort = 1;
 659                                 break;
 660                         }
 661
 662                         /* see page 22 of XSVF spec */
 663                         if( uc == 0 )
 664                                 xenddr = TAP_IDLE;
 665                         else if( uc == 1 )
 666                                 xenddr = TAP_DRPAUSE;
 667                         else
 668                         {
 669                                 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
 670                                 unsupported = 1;
 671                                 break;
 672                         }
 673
 674                         LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
 675                         break;
 676
 677                 case XSIR:
 678                 case XSIR2:
 679                         {
 680                                 u8      short_buf[2];
 681                                 u8*     ir_buf;
 682                                 int bitcount;
 683                                 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
 684
 685                                 if( opcode == XSIR )
 686                                 {
 687                                         /* one byte bitcount */
 688                                         if (read(xsvf_fd, short_buf, 1) < 0)
 689                                         {
 690                                                 do_abort = 1;
 691                                                 break;
 692                                         }
 693                                         bitcount = short_buf[0];
 694                                         LOG_DEBUG("XSIR %d", bitcount);
 695                                 }
 696                                 else
 697                                 {
 698                                         if (read(xsvf_fd, short_buf, 2) < 0)
 699                                         {
 700                                                 do_abort = 1;
 701                                                 break;
 702                                         }
 703                                         bitcount = be_to_h_u16(short_buf);
 704                                         LOG_DEBUG("XSIR2 %d", bitcount);
 705                                 }
 706
 707                                 ir_buf = malloc((bitcount+7) / 8);
 708
 709                                 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
 710                                         do_abort = 1;
 711                                 else
 712                                 {
 713                                         scan_field_t field;
 714
 715                                         field.tap = tap;
 716                                         field.num_bits = bitcount;
 717                                         field.out_value = ir_buf;
 718
 719                                         field.in_value = NULL;
 720
 721
 722
 723
 724                                         if (tap == NULL)
 725                                                 jtag_add_plain_ir_scan(1, &field, my_end_state);
 726                                         else
 727                                                 jtag_add_ir_scan(1, &field, my_end_state);
 728
 729                                         if (xruntest)
 730                                         {
 731                                                 if (runtest_requires_tck)
 732                                                         jtag_add_clocks(xruntest);
 733                                                 else
 734                                                         jtag_add_sleep(xruntest);
 735                                         }
 736
 737                                         /* Note that an -irmask of non-zero in your config file
 738                                          * can cause this to fail.  Setting -irmask to zero cand work
 739                                          * around the problem.
 740                                          */
 741
 742                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 743                                         result = jtag_execute_queue();
 744                                         if(result != ERROR_OK)
 745                                         {
 746                                                 tdo_mismatch = 1;
 747                                         }
 748                                 }
 749                                 free(ir_buf);
 750                         }
 751                         break;
 752
 753                 case XCOMMENT:
 754                         {
 755                                 unsigned int ndx = 0;
 756                                 char    comment[128];
 757
 758                                 do
 759                                 {
 760                                         if (read(xsvf_fd, &uc, 1) < 0)
 761                                         {
 762                                                 do_abort = 1;
 763                                                 break;
 764                                         }
 765
 766                                         if ( ndx < sizeof(comment)-1 )
 767                                                 comment[ndx++] = uc;
 768
 769                                 } while (uc != 0);
 770
 771                                 comment[sizeof(comment)-1] = 0;         /* regardless, terminate */
 772                                 if (verbose)
 773                                         LOG_USER("# %s", comment);
 774                         }
 775                         break;
 776
 777                 case XWAIT:
 778                         {
 779                                 /* expected in stream:
 780                                    XWAIT <u8 wait_state> <u8 end_state> <u32 usecs>
 781                                 */
 782
 783                                 u8      wait;
 784                                 u8      end;
 785                                 u8      delay_buf[4];
 786
 787                                 tap_state_t wait_state;
 788                                 tap_state_t end_state;
 789                                 int     delay;
 790
 791                                 if ( read(xsvf_fd, &wait, 1) < 0
 792                                   || read(xsvf_fd, &end, 1) < 0
 793                                   || read(xsvf_fd, delay_buf, 4) < 0)
 794                                 {
 795                                         do_abort = 1;
 796                                         break;
 797                                 }
 798
 799                                 wait_state = xsvf_to_tap(wait);
 800                                 end_state  = xsvf_to_tap(end);
 801                                 delay      = be_to_h_u32(delay_buf);
 802
 803                                 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
 804
 805                                 if (runtest_requires_tck && wait_state == TAP_IDLE )
 806                                 {
 807                                         jtag_add_runtest(delay, end_state);
 808                                 }
 809                                 else
 810                                 {
 811                                         xsvf_add_statemove( wait_state );
 812                                         jtag_add_sleep(delay);
 813                                         xsvf_add_statemove( end_state );
 814                                 }
 815                         }
 816                         break;
 817
 818                 case XWAITSTATE:
 819                         {
 820                                 /* expected in stream:
 821                                    XWAITSTATE <u8 wait_state> <u8 end_state> <u32 clock_count> <u32 usecs>
 822                                 */
 823
 824                                 u8  clock_buf[4];
 825                                 u8      usecs_buf[4];
 826                                 u8      wait;
 827                                 u8      end;
 828                                 tap_state_t wait_state;
 829                                 tap_state_t end_state;
 830                                 int clock_count;
 831                                 int usecs;
 832
 833                                 if ( read(xsvf_fd, &wait, 1) < 0
 834                                  ||  read(xsvf_fd, &end, 1) < 0
 835                                  ||  read(xsvf_fd, clock_buf, 4) < 0
 836                                  ||  read(xsvf_fd, usecs_buf, 4) < 0 )
 837                                 {
 838                                         do_abort = 1;
 839                                         break;
 840                                 }
 841
 842                                 wait_state = xsvf_to_tap( wait );
 843                                 end_state  = xsvf_to_tap( end );
 844
 845                                 clock_count = be_to_h_u32(clock_buf);
 846                                 usecs       = be_to_h_u32(usecs_buf);
 847
 848                                 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
 849                                         tap_state_name(wait_state),
 850                                         tap_state_name(end_state),
 851                                         clock_count, usecs);
 852
 853                                 /* the following states are 'stable', meaning that they have a transition
 854                                  * in the state diagram back to themselves.  This is necessary because we will
 855                                  * be issuing a number of clocks in this state.  This set of allowed states is also
 856                                  * determined by the SVF RUNTEST command's allowed states.
 857                                  */
 858                                 if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE)
 859                                 {
 860                                         LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state ));
 861                                         unsupported = 1;
 862                                 }
 863
 864                                 xsvf_add_statemove( wait_state );
 865
 866                                 jtag_add_clocks( clock_count );
 867
 868                                 jtag_add_sleep( usecs );
 869
 870                                 xsvf_add_statemove( end_state );
 871                         }
 872                         break;
 873
 874                 case LCOUNT:
 875                         {
 876                                 /* expected in stream:
 877                                    LCOUNT <u32 loop_count>
 878                                 */
 879                                 u8  count_buf[4];
 880
 881                                 if ( read(xsvf_fd, count_buf, 4) < 0 )
 882                                 {
 883                                         do_abort = 1;
 884                                         break;
 885                                 }
 886
 887                                 loop_count = be_to_h_u32(count_buf);
 888                                 LOG_DEBUG("LCOUNT %d", loop_count);
 889                         }
 890                         break;
 891
 892                 case LDELAY:
 893                         {
 894                                 /* expected in stream:
 895                                    LDELAY <u8 wait_state> <u32 clock_count> <u32 usecs_to_sleep>
 896                                 */
 897                                 u8      state;
 898                                 u8  clock_buf[4];
 899                                 u8  usecs_buf[4];
 900
 901                                 if ( read(xsvf_fd, &state, 1) < 0
 902                                   || read(xsvf_fd, clock_buf, 4) < 0
 903                                   ||     read(xsvf_fd, usecs_buf, 4) < 0 )
 904                                 {
 905                                         do_abort = 1;
 906                                         break;
 907                                 }
 908
 909                                 loop_state  = xsvf_to_tap(state);
 910                                 loop_clocks = be_to_h_u32(clock_buf);
 911                                 loop_usecs  = be_to_h_u32(usecs_buf);
 912
 913                                 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
 914                         }
 915                         break;
 916
 917                 /* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
 918                  * comes with clocks !AND! sleep requirements.
 919                  */
 920                 case LSDR:
 921                         {
 922                                 int limit = loop_count;
 923                                 int matched = 0;
 924                                 int attempt;
 925
 926                                 LOG_DEBUG("LSDR");
 927
 928                                 if ( xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
 929                                   || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
 930                                 {
 931                                         do_abort = 1;
 932                                         break;
 933                                 }
 934
 935                                 if (limit < 1)
 936                                         limit = 1;
 937
 938                                 for( attempt=0; attempt<limit;  ++attempt )
 939                                 {
 940                                         scan_field_t field;
 941
 942                                         xsvf_add_statemove( loop_state );
 943                                         jtag_add_clocks(loop_clocks);
 944                                         jtag_add_sleep(loop_usecs);
 945
 946                                         field.tap = tap;
 947                                         field.num_bits = xsdrsize;
 948                                         field.out_value = dr_out_buf;
 949                                         field.in_value = calloc(CEIL(field.num_bits, 8), 1);
 950
 951                                         if (attempt > 0 && verbose)
 952                                                 LOG_USER("LSDR retry %d", attempt);
 953
 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                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 960
 961                                         free(field.in_value);
 962
 963
 964                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 965                                         result = jtag_execute_queue();
 966                                         if(result == ERROR_OK)
 967                                         {
 968                                                 matched = 1;
 969                                                 break;
 970                                         }
 971                                 }
 972
 973                                 if (!matched )
 974                                 {
 975                                         LOG_USER( "LSDR mismatch" );
 976                                         tdo_mismatch = 1;
 977                                         break;
 978                                 }
 979                         }
 980                         break;
 981
 982                 case XTRST:
 983                         {
 984                                 u8      trst_mode;
 985
 986                                 if (read(xsvf_fd, &trst_mode, 1) < 0)
 987                                 {
 988                                         do_abort = 1;
 989                                         break;
 990                                 }
 991
 992                                 switch( trst_mode )
 993                                 {
 994                                 case XTRST_ON:
 995                                         jtag_add_reset(1, 0);
 996                                         break;
 997                                 case XTRST_OFF:
 998                                 case XTRST_Z:
 999                                         jtag_add_reset(0, 0);
1000                                         break;
1001                                 case XTRST_ABSENT:
1002                                         break;
1003                                 default:
1004                                         LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode );
1005                                         do_abort = 1;
1006                                 }
1007                         }
1008                         break;
1009
1010                 default:
1011                         LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
1012                         unsupported = 1;
1013                 }
1014
1015                 if (do_abort || unsupported || tdo_mismatch)
1016                 {
1017                         LOG_DEBUG("xsvf failed, setting taps to reasonable state");
1018
1019                         /* upon error, return the TAPs to a reasonable state */
1020                         xsvf_add_statemove( TAP_IDLE );
1021                         jtag_execute_queue();
1022                         break;
1023                 }
1024         }
1025
1026         if (tdo_mismatch)
1027         {
1028                 command_print(cmd_ctx, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1029                                           file_offset );
1030
1031
1032                 return ERROR_FAIL;
1033         }
1034
1035         if (unsupported)
1036         {
1037                 command_print(cmd_ctx,
1038                          "unsupported xsvf command: 0x%02X in xsvf file at offset %ld, aborting",
1039                                           uc,  lseek(xsvf_fd, 0, SEEK_CUR)-1 );
1040                 return ERROR_FAIL;
1041         }
1042
1043         if (do_abort)
1044         {
1045                 command_print(cmd_ctx, "premature end of xsvf file detected, aborting");
1046                 return ERROR_FAIL;
1047         }
1048
1049         if (dr_out_buf)
1050                 free(dr_out_buf);
1051
1052         if (dr_in_buf)
1053                 free(dr_in_buf);
1054
1055         if (dr_in_mask)
1056                 free(dr_in_mask);
1057
1058         close(xsvf_fd);
1059
1060         command_print(cmd_ctx, "XSVF file programmed successfully");
1061
1062         return ERROR_OK;
1063 }
1064
1065
1066 #if 0   /* this comment style used to try and keep uncrustify from adding * at begin of line */
1067
1068 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
1069
1070 the following pseudo code clarifies the intent of the xrepeat support.  The
1071 flow given is for the entire processing of an SVF file, not an XSVF file.
1072 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1073
1074 "Pseudo-Code Algorithm for SVF-Based ISP"
1075
1076 1. Go to Test-Logic-Reset state
1077 2. Go to Run-Test Idle state
1078 3. Read SVF record
1079
1080 4. if SIR record then
1081            go to Shift-IR state
1082            Scan in <TDI value>
1083
1084 5. else if SDR record then
1085            set <repeat count> to 0
1086            store <TDI value> as <current TDI value>
1087            store <TDO value> as <current TDO value>
1088 6. go to Shift-DR state
1089            scan in <current TDI value>
1090            if <current TDO value> is specified then
1091                    if <current TDO value> does not equal <actual TDO value> then
1092                            if <repeat count> > 32 then
1093                                    LOG ERROR
1094                                    go to Run-Test Idle state
1095                                    go to Step 3
1096                            end if
1097                            go to Pause-DR
1098                            go to Exit2-DR
1099                            go to Shift-DR
1100                            go to Exit1-DR
1101                            go to Update-DR
1102                            go to Run-Test/Idle
1103                            increment <repeat count> by 1
1104                            pause <current pause time> microseconds
1105                            go to Step 6)
1106                    end if
1107            else
1108                    go to Run-Test Idle state
1109                    go to Step 3
1110            endif
1111 else if RUNTEST record then
1112    pause tester for <TCK value> microseconds
1113    store <TCK value> as <current pause time>
1114 end if
1115
1116 #endif