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@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
  57 #include <sys/time.h>
  58 #include <time.h>
  59
  60
  61 /* XSVF commands, from appendix B of xapp503.pdf  */
  62 #define XCOMPLETE               0x00
  63 #define XTDOMASK                        0x01
  64 #define XSIR                            0x02
  65 #define XSDR                            0x03
  66 #define XRUNTEST                        0x04
  67 #define XREPEAT                 0x07
  68 #define XSDRSIZE                        0x08
  69 #define XSDRTDO                 0x09
  70 #define XSETSDRMASKS            0x0A
  71 #define XSDRINC                 0x0B
  72 #define XSDRB                   0x0C
  73 #define XSDRC                   0x0D
  74 #define XSDRE                   0x0E
  75 #define XSDRTDOB                        0x0F
  76 #define XSDRTDOC                        0x10
  77 #define XSDRTDOE                        0x11
  78 #define XSTATE                  0x12
  79 #define XENDIR                  0x13
  80 #define XENDDR                  0x14
  81 #define XSIR2                   0x15
  82 #define XCOMMENT                        0x16
  83 #define XWAIT                   0x17
  84
  85 /* XWAITSTATE is not in the xilinx XSVF spec, but the svf2xsvf.py translator
  86  * generates this.  Arguably it is needed because the XSVF XRUNTEST command
  87  * was ill conceived and does not directly flow out of the SVF RUNTEST command.
  88  * This XWAITSTATE does map directly from the SVF RUNTEST command.
  89  */
  90 #define XWAITSTATE              0x18
  91
  92 /* Lattice has extended the SVF file format, and Dick Hollenbeck's python based
  93  * SVF2XSVF converter supports these 3 additional XSVF opcodes, LCOUNT, LDELAY, LSDR.
  94  * Here is an example of usage of the 3 lattice opcode extensions:
  95
  96 ! Set the maximum loop count to 25.
  97 LCOUNT  25;
  98 ! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.
  99 LDELAY  DRPAUSE 5 TCK   1.00E-003 SEC;
 100 ! Test for the completed status. Match means pass.
 101 ! Loop back to LDELAY line if not match and loop count less than 25.
 102
 103 LSDR 1  TDI  (0)
 104                 TDO  (1);
 105 */
 106
 107 #define LCOUNT                  0x19
 108 #define LDELAY                  0x1A
 109 #define LSDR                            0x1B
 110 #define XTRST                   0x1C
 111
 112
 113 /* XSVF valid state values for the XSTATE command, from appendix B of xapp503.pdf */
 114 #define XSV_RESET               0x00
 115 #define XSV_IDLE                        0x01
 116 #define XSV_DRSELECT            0x02
 117 #define XSV_DRCAPTURE   0x03
 118 #define XSV_DRSHIFT             0x04
 119 #define XSV_DREXIT1             0x05
 120 #define XSV_DRPAUSE             0x06
 121 #define XSV_DREXIT2             0x07
 122 #define XSV_DRUPDATE            0x08
 123 #define XSV_IRSELECT            0x09
 124 #define XSV_IRCAPTURE   0x0A
 125 #define XSV_IRSHIFT             0x0B
 126 #define XSV_IREXIT1             0x0C
 127 #define XSV_IRPAUSE             0x0D
 128 #define XSV_IREXIT2             0x0E
 129 #define XSV_IRUPDATE            0x0F
 130
 131 /* arguments to XTRST */
 132 #define XTRST_ON                        0
 133 #define XTRST_OFF               1
 134 #define XTRST_Z                 2
 135 #define XTRST_ABSENT            3
 136
 137 #define XSTATE_MAX_PATH 12
 138
 139 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 140
 141 static int xsvf_fd = 0;
 142
 143
 144 /* map xsvf tap state to an openocd "enum tap_state" */
 145 static tap_state_t xsvf_to_tap( int xsvf_state )
 146 {
 147         tap_state_t     ret;
 148
 149         switch( xsvf_state )
 150         {
 151         case XSV_RESET:                 ret = TAP_RESET;                        break;
 152         case XSV_IDLE:                  ret = TAP_IDLE;                 break;
 153         case XSV_DRSELECT:              ret = TAP_DRSELECT;             break;
 154         case XSV_DRCAPTURE:             ret = TAP_DRCAPTURE;            break;
 155         case XSV_DRSHIFT:               ret = TAP_DRSHIFT;              break;
 156         case XSV_DREXIT1:               ret = TAP_DREXIT1;              break;
 157         case XSV_DRPAUSE:               ret = TAP_DRPAUSE;              break;
 158         case XSV_DREXIT2:               ret = TAP_DREXIT2;              break;
 159         case XSV_DRUPDATE:              ret = TAP_DRUPDATE;             break;
 160         case XSV_IRSELECT:              ret = TAP_IRSELECT;             break;
 161         case XSV_IRCAPTURE:             ret = TAP_IRCAPTURE;            break;
 162         case XSV_IRSHIFT:               ret = TAP_IRSHIFT;              break;
 163         case XSV_IREXIT1:               ret = TAP_IREXIT1;              break;
 164         case XSV_IRPAUSE:               ret = TAP_IRPAUSE;              break;
 165         case XSV_IREXIT2:               ret = TAP_IREXIT2;              break;
 166         case XSV_IRUPDATE:              ret = TAP_IRUPDATE;             break;
 167         default:
 168                 LOG_ERROR( "UNKNOWN XSVF STATE 0x%02X", xsvf_state );
 169                 exit(1);
 170         }
 171
 172         return ret;
 173 }
 174
 175
 176 /* xsvf has it's own definition of a statemove. This needs
 177  * to be handled according to the xsvf spec, which has nothing
 178  * to do with the JTAG spec or OpenOCD as such.
 179  *
 180  * Implemented via jtag_add_pathmove().
 181  */
 182 static void xsvf_add_statemove(tap_state_t state)
 183 {
 184         tap_state_t moves[7];   /* max # of transitions */
 185         tap_state_t curstate = cmd_queue_cur_state;
 186         int i;
 187
 188         u8 move = TAP_MOVE(cmd_queue_cur_state, state);
 189
 190         if (state != TAP_RESET  &&  state==cmd_queue_cur_state)
 191                 return;
 192
 193         if(state==TAP_RESET)
 194         {
 195                 jtag_add_tlr();
 196                 return;
 197         }
 198
 199         for (i=0; i<7; i++)
 200         {
 201                 int j = (move >> i) & 1;
 202                 if (j)
 203                 {
 204                         curstate = tap_transitions[curstate].high;
 205                 }
 206                 else
 207                 {
 208                         curstate = tap_transitions[curstate].low;
 209                 }
 210                 moves[i] = curstate;
 211         }
 212
 213         jtag_add_pathmove(7, moves);
 214 }
 215
 216 int xsvf_register_commands(struct command_context_s *cmd_ctx)
 217 {
 218         register_command(cmd_ctx, NULL, "xsvf", handle_xsvf_command,
 219                 COMMAND_EXEC, "run xsvf <file> [virt2] [quiet]");
 220
 221         return ERROR_OK;
 222 }
 223
 224 static int xsvf_read_buffer(int num_bits, int fd, u8* buf)
 225 {
 226         int num_bytes;
 227
 228         for (num_bytes = (num_bits + 7) / 8; num_bytes > 0; num_bytes--)
 229         {
 230                 /* reverse the order of bytes as they are read sequentially from file */
 231                 if (read(fd, buf + num_bytes - 1, 1) < 0)
 232                         return ERROR_XSVF_EOF;
 233         }
 234
 235         return ERROR_OK;
 236 }
 237
 238
 239 static int xsvf_read_xstates(int fd, tap_state_t *path, int max_path, int *path_len)
 240 {
 241         char c;
 242         u8   uc;
 243
 244         while ((read(fd, &c, 1) > 0) && (c == XSTATE))
 245         {
 246                 tap_state_t     mystate;
 247
 248                 if (*path_len > max_path)
 249                 {
 250                         LOG_WARNING("XSTATE path longer than max_path");
 251                         break;
 252                 }
 253                 if (read(fd, &uc, 1) < 0)
 254                 {
 255                         return ERROR_XSVF_EOF;
 256                 }
 257
 258                 mystate = xsvf_to_tap(uc);
 259
 260                 LOG_DEBUG("XSTATE %02X %s", uc, jtag_state_name(mystate) );
 261
 262                 path[(*path_len)++] = mystate;
 263         }
 264
 265         lseek(fd, -1, SEEK_CUR);
 266
 267         return ERROR_OK;
 268 }
 269
 270
 271 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 272 {
 273         u8 *dr_out_buf = NULL;                          /* from host to device (TDI) */
 274         u8 *dr_in_buf = NULL;                           /* from device to host (TDO) */
 275         u8 *dr_in_mask = NULL;
 276
 277         int xsdrsize = 0;
 278         int xruntest = 0;                                       /* number of TCK cycles OR microseconds */
 279         int xrepeat      = 0;                                   /* number of retries */
 280
 281         tap_state_t     xendir = TAP_IDLE;              /* see page 8 of the SVF spec, initial xendir to be TAP_IDLE */
 282         tap_state_t xenddr = TAP_IDLE;
 283
 284         u8              opcode;
 285         u8              uc;
 286         long            file_offset = 0;
 287
 288         int             loop_count = 0;
 289         tap_state_t     loop_state = TAP_IDLE;
 290         int             loop_clocks = 0;
 291         int             loop_usecs = 0;
 292
 293         int             do_abort = 0;
 294         int             unsupported = 0;
 295         int             tdo_mismatch = 0;
 296         int             result;
 297         int             verbose = 1;
 298         char*   filename;
 299
 300         int             runtest_requires_tck = 0;       /* a flag telling whether to clock TCK during waits, or simply sleep, controled by virt2 */
 301
 302
 303         /* use NULL to indicate a "plain" xsvf file which accounts for
 304            additional devices in the scan chain, otherwise the device
 305            that should be affected
 306         */
 307         jtag_tap_t *tap = NULL;
 308
 309         if (argc < 2)
 310         {
 311                 command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
 312                 return ERROR_FAIL;
 313         }
 314
 315         filename = args[1];             /* we mess with args starting point below, snapshot filename here */
 316
 317         if (strcmp(args[0], "plain") != 0)
 318         {
 319                 tap = jtag_TapByString( args[0] );
 320                 if (!tap )
 321                 {
 322                         command_print( cmd_ctx, "Tap: %s unknown", args[0] );
 323                         return ERROR_FAIL;
 324                 }
 325         }
 326
 327         if ((xsvf_fd = open(filename, O_RDONLY)) < 0)
 328         {
 329                 command_print(cmd_ctx, "file \"%s\" not found", filename);
 330                 return ERROR_FAIL;
 331         }
 332
 333         /* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
 334         if ((argc > 2) && (strcmp(args[2], "virt2") == 0))
 335         {
 336                 runtest_requires_tck = 1;
 337                 --argc;
 338                 ++args;
 339         }
 340
 341         if ((argc > 2) && (strcmp(args[2], "quiet") == 0))
 342         {
 343                 verbose = 0;
 344         }
 345
 346         LOG_USER("xsvf processing file: \"%s\"", filename);
 347
 348         while( read(xsvf_fd, &opcode, 1) > 0 )
 349         {
 350                 /* record the position of the just read opcode within the file */
 351                 file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
 352
 353                 switch (opcode)
 354                 {
 355                         case XCOMPLETE:
 356                                 LOG_DEBUG("XCOMPLETE");
 357
 358                                 result = jtag_execute_queue();
 359                                 if (result != ERROR_OK)
 360                                 {
 361                                         tdo_mismatch = 1;
 362                                         break;
 363                                 }
 364                                 break;
 365
 366                         case XTDOMASK:
 367                                 LOG_DEBUG("XTDOMASK");
 368                                 if (dr_in_mask && (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
 369                                         do_abort = 1;
 370                                 break;
 371
 372                         case XRUNTEST:
 373                                 {
 374                                         u8      xruntest_buf[4];
 375
 376                                         if (read(xsvf_fd, xruntest_buf, 4) < 0)
 377                                         {
 378                                                 do_abort = 1;
 379                                                 break;
 380                                         }
 381
 382                                         xruntest = be_to_h_u32(xruntest_buf);
 383                                         LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
 384                                 }
 385                                 break;
 386
 387                         case XREPEAT:
 388                                 {
 389                                         u8 myrepeat;
 390
 391                                         if (read(xsvf_fd, &myrepeat, 1) < 0)
 392                                                 do_abort = 1;
 393                                         else
 394                                         {
 395                                                 xrepeat = myrepeat;
 396                                                 LOG_DEBUG("XREPEAT %d", xrepeat );
 397                                         }
 398                                 }
 399                                 break;
 400
 401                         case XSDRSIZE:
 402                                 {
 403                                         u8      xsdrsize_buf[4];
 404
 405                                         if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
 406                                         {
 407                                                 do_abort = 1;
 408                                                 break;
 409                                         }
 410
 411                                         xsdrsize = be_to_h_u32(xsdrsize_buf);
 412                                         LOG_DEBUG("XSDRSIZE %d", xsdrsize);
 413
 414                                         if( dr_out_buf ) free(dr_out_buf);
 415                                         if( dr_in_buf)   free(dr_in_buf);
 416                                         if( dr_in_mask)  free(dr_in_mask);
 417
 418                                         dr_out_buf = malloc((xsdrsize + 7) / 8);
 419                                         dr_in_buf = malloc((xsdrsize + 7) / 8);
 420                                         dr_in_mask = malloc((xsdrsize + 7) / 8);
 421                                 }
 422                                 break;
 423
 424                         case XSDR:              /* these two are identical except for the dr_in_buf */
 425                         case XSDRTDO:
 426                                 {
 427                                         int limit = xrepeat;
 428                                         int     matched = 0;
 429                                         int attempt;
 430
 431                                         const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
 432
 433                                         if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
 434                                         {
 435                                                 do_abort = 1;
 436                                                 break;
 437                                         }
 438
 439                                         if (opcode == XSDRTDO)
 440                                         {
 441                                                 if(xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf)  != ERROR_OK )
 442                                                 {
 443                                                         do_abort = 1;
 444                                                         break;
 445                                                 }
 446                                         }
 447
 448                                         if (limit < 1)
 449                                                 limit = 1;
 450
 451                                         LOG_DEBUG("%s %d", op_name, xsdrsize);
 452
 453                                         for( attempt=0; attempt<limit;  ++attempt )
 454                                         {
 455                                                 scan_field_t field;
 456
 457                                                 if( attempt>0 )
 458                                                 {
 459                                                         /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
 460                                                            illustrated in psuedo code at end of this file.  We start from state
 461                                                            DRPAUSE:
 462                                                            go to Exit2-DR
 463                                                            go to Shift-DR
 464                                                            go to Exit1-DR
 465                                                            go to Update-DR
 466                                                            go to Run-Test/Idle
 467
 468                                                            This sequence should be harmless for other devices, and it
 469                                                            will be skipped entirely if xrepeat is set to zero.
 470                                                         */
 471
 472                                                         static tap_state_t exception_path[] = {
 473                                                                 TAP_DREXIT2,
 474                                                                 TAP_DRSHIFT,
 475                                                                 TAP_DREXIT1,
 476                                                                 TAP_DRUPDATE,
 477                                                                 TAP_IDLE,
 478                                                         };
 479
 480                                                         jtag_add_pathmove( sizeof(exception_path)/sizeof(exception_path[0]), exception_path);
 481
 482                                                         if (verbose)
 483                                                                 LOG_USER("%s %d retry %d", op_name, xsdrsize, attempt);
 484                                                 }
 485
 486                                                 field.tap = tap;
 487                                                 field.num_bits = xsdrsize;
 488                                                 field.out_value = dr_out_buf;
 489                                                 field.out_mask = NULL;
 490                                                 field.in_value = NULL;
 491
 492                                                 jtag_set_check_value(&field, dr_in_buf, dr_in_mask, NULL);
 493
 494                                                 if (tap == NULL)
 495                                                         jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
 496                                                 else
 497                                                         jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
 498
 499                                                 /* LOG_DEBUG("FLUSHING QUEUE"); */
 500                                                 result = jtag_execute_queue();
 501                                                 if (result == ERROR_OK)
 502                                                 {
 503                                                         matched = 1;
 504                                                         break;
 505                                                 }
 506                                         }
 507
 508                                         if (!matched)
 509                                         {
 510                                                 LOG_USER( "%s mismatch", op_name);
 511                                                 tdo_mismatch = 1;
 512                                                 break;
 513                                         }
 514
 515                                         /* See page 19 of XSVF spec regarding opcode "XSDR" */
 516                                         if (xruntest)
 517                                         {
 518                                                 xsvf_add_statemove(TAP_IDLE);
 519
 520                                                 if (runtest_requires_tck)
 521                                                         jtag_add_clocks(xruntest);
 522                                                 else
 523                                                         jtag_add_sleep(xruntest);
 524                                         }
 525                                         else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
 526                                                 xsvf_add_statemove(xenddr);
 527                                 }
 528                                 break;
 529
 530                         case XSETSDRMASKS:
 531                                 LOG_ERROR("unsupported XSETSDRMASKS\n");
 532                                 unsupported = 1;
 533                                 break;
 534
 535                         case XSDRINC:
 536                                 LOG_ERROR("unsupported XSDRINC\n");
 537                                 unsupported = 1;
 538                                 break;
 539
 540                         case XSDRB:
 541                                 LOG_ERROR("unsupported XSDRB\n");
 542                                 unsupported = 1;
 543                                 break;
 544
 545                         case XSDRC:
 546                                 LOG_ERROR("unsupported XSDRC\n");
 547                                 unsupported = 1;
 548                                 break;
 549
 550                         case XSDRE:
 551                                 LOG_ERROR("unsupported XSDRE\n");
 552                                 unsupported = 1;
 553                                 break;
 554
 555                         case XSDRTDOB:
 556                                 LOG_ERROR("unsupported XSDRTDOB\n");
 557                                 unsupported = 1;
 558                                 break;
 559
 560                         case XSDRTDOC:
 561                                 LOG_ERROR("unsupported XSDRTDOC\n");
 562                                 unsupported = 1;
 563                                 break;
 564
 565                         case XSDRTDOE:
 566                                 LOG_ERROR("unsupported XSDRTDOE\n");
 567                                 unsupported = 1;
 568                                 break;
 569
 570                         case XSTATE:
 571                                 {
 572                                         tap_state_t     mystate;
 573                                         tap_state_t *path;
 574                                         int path_len;
 575
 576                                         if (read(xsvf_fd, &uc, 1) < 0)
 577                                         {
 578                                                 do_abort = 1;
 579                                                 break;
 580                                         }
 581
 582                                         mystate = xsvf_to_tap(uc);
 583
 584                                         LOG_DEBUG("XSTATE 0x%02X %s", uc, jtag_state_name(mystate) );
 585
 586                                         path = calloc(XSTATE_MAX_PATH, 4);
 587                                         path_len = 1;
 588
 589                                         path[0] = mystate;
 590                                         if (xsvf_read_xstates(xsvf_fd, path, XSTATE_MAX_PATH, &path_len) != ERROR_OK)
 591                                                 do_abort = 1;
 592                                         else
 593                                         {
 594                                                 int i,lasti;
 595
 596                                                 /* here the trick is that jtag_add_pathmove() must end in a stable
 597                                                  * state, so we must only invoke jtag_add_tlr() when we absolutely
 598                                                  * have to
 599                                                  */
 600                                                 for(i=0,lasti=0;  i<path_len;  i++)
 601                                                 {
 602                                                         if(path[i]==TAP_RESET)
 603                                                         {
 604                                                                 if(i>lasti)
 605                                                                 {
 606                                                                         jtag_add_pathmove(i-lasti,path+lasti);
 607                                                                 }
 608                                                                 lasti=i+1;
 609                                                                 jtag_add_tlr();
 610                                                         }
 611                                                 }
 612                                                 if(i>=lasti)
 613                                                 {
 614                                                         jtag_add_pathmove(i-lasti, path+lasti);
 615                                                 }
 616                                         }
 617                                         free(path);
 618                                 }
 619                                 break;
 620
 621                         case XENDIR:
 622                                 {
 623                                         tap_state_t      mystate;
 624
 625                                         if (read(xsvf_fd, &uc, 1) < 0)
 626                                         {
 627                                                 do_abort = 1;
 628                                                 break;
 629                                         }
 630
 631                                         /* see page 22 of XSVF spec */
 632                                         mystate = uc == 1 ? TAP_IRPAUSE : TAP_IDLE;
 633
 634                                         LOG_DEBUG("XENDIR 0x%02X %s", uc, jtag_state_name(mystate));
 635
 636                                         /* assuming that the XRUNTEST comes from SVF RUNTEST, then only these states
 637                                          * should come here because the SVF spec only allows these with a RUNTEST
 638                                          */
 639                                         if (mystate != TAP_IRPAUSE && mystate != TAP_DRPAUSE && mystate != TAP_RESET && mystate != TAP_IDLE )
 640                                         {
 641                                                 LOG_ERROR("illegal XENDIR endstate: \"%s\"", jtag_state_name(mystate));
 642                                                 unsupported = 1;
 643                                                 break;
 644                                         }
 645                                         xendir = mystate;
 646                                 }
 647                                 break;
 648
 649                         case XENDDR:
 650                                 {
 651                                         tap_state_t      mystate;
 652
 653                                         if (read(xsvf_fd, &uc, 1) < 0)
 654                                         {
 655                                                 do_abort = 1;
 656                                                 break;
 657                                         }
 658
 659                                         /* see page 22 of XSVF spec */
 660                                         mystate = uc == 1 ? TAP_DRPAUSE : TAP_IDLE;
 661
 662                                         LOG_DEBUG("XENDDR %02X %s", uc, jtag_state_name(mystate));
 663
 664                                         if (mystate != TAP_IRPAUSE && mystate != TAP_DRPAUSE && mystate != TAP_RESET && mystate != TAP_IDLE )
 665                                         {
 666                                                 LOG_ERROR("illegal XENDDR endstate: \"%s\"", jtag_state_name( mystate ));
 667                                                 unsupported = 1;
 668                                                 break;
 669                                         }
 670                                         xenddr = mystate;
 671                                 }
 672                                 break;
 673
 674                         case XSIR:
 675                         case XSIR2:
 676                                 {
 677                                         u8      short_buf[2];
 678                                         u8*     ir_buf;
 679                                         int bitcount;
 680                                         tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
 681
 682                                         if( opcode == XSIR )
 683                                         {
 684                                                 /* one byte bitcount */
 685                                                 if (read(xsvf_fd, short_buf, 1) < 0)
 686                                                 {
 687                                                         do_abort = 1;
 688                                                         break;
 689                                                 }
 690                                                 bitcount = short_buf[0];
 691                                                 LOG_DEBUG("XSIR %d", bitcount);
 692                                         }
 693                                         else
 694                                         {
 695                                                 if (read(xsvf_fd, short_buf, 2) < 0)
 696                                                 {
 697                                                         do_abort = 1;
 698                                                         break;
 699                                                 }
 700                                                 bitcount = be_to_h_u16(short_buf);
 701                                                 LOG_DEBUG("XSIR2 %d", bitcount);
 702                                         }
 703
 704                                         ir_buf = malloc((bitcount+7) / 8);
 705
 706                                         if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
 707                                                 do_abort = 1;
 708                                         else
 709                                         {
 710                                                 scan_field_t field;
 711
 712                                                 field.tap = tap;
 713                                                 field.num_bits = bitcount;
 714                                                 field.out_value = ir_buf;
 715                                                 field.out_mask = NULL;
 716                                                 field.in_value = NULL;
 717                                                 field.in_check_value = NULL;
 718                                                 field.in_check_mask = NULL;
 719                                                 field.in_handler = NULL;
 720                                                 field.in_handler_priv = 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                                         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(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", jtag_state_name(wait_state), jtag_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                                                 jtag_state_name(wait_state),
 848                                                 jtag_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\"", jtag_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", jtag_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                                                 field.out_mask = NULL;
 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 /* PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
1062
1063 the following pseudo code clarifies the intent of the xrepeat support.  The
1064 flow given is for the entire processing of an SVF file, not an XSVF file.
1065 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1066
1067 "Pseudo-Code Algorithm for SVF-Based ISP"
1068
1069 1. Go to Test-Logic-Reset state
1070 2. Go to Run-Test Idle state
1071 3. Read SVF record
1072
1073 4. if SIR record then
1074            go to Shift-IR state
1075            Scan in <TDI value>
1076
1077 5. else if SDR record then
1078            set <repeat count> to 0
1079            store <TDI value> as <current TDI value>
1080            store <TDO value> as <current TDO value>
1081 6. go to Shift-DR state
1082            scan in <current TDI value>
1083            if <current TDO value> is specified then
1084                    if <current TDO value> does not equal <actual TDO value> then
1085                            if <repeat count> > 32 then
1086                                    LOG ERROR
1087                                    go to Run-Test Idle state
1088                                    go to Step 3
1089                            end if
1090                            go to Pause-DR
1091                            go to Exit2-DR
1092                            go to Shift-DR
1093                            go to Exit1-DR
1094                            go to Update-DR
1095                            go to Run-Test/Idle
1096                            increment <repeat count> by 1
1097                            pause <current pause time> microseconds
1098                            go to Step 6)
1099                    end if
1100            else
1101                    go to Run-Test Idle state
1102                    go to Step 3
1103            endif
1104 else if RUNTEST record then
1105    pause tester for <TCK value> microseconds
1106    store <TCK value> as <current pause time>
1107 end if
1108
1109 */