git.gag.com Git - fw/openocd/blob - src/xsvf/xsvf.c

   1 /***************************************************************************
   2  *       Copyright (C) 2005 by Dominic Rath                                                                        *
   3  *       Dominic.Rath@gmx.de                                                                                                       *
   4  *                                                                                                                                                 *
   5  *       Copyright (C) 2007,2008 Øyvind Harboe                                                             *
   6  *       oyvind.harboe@zylin.com                                                                                                   *
   7  *                                                                                                                                                 *
   8  *       Copyright (C) 2008 Peter Hettkamp                                                                         *
   9  *       peter.hettkamp@htp-tel.de                                                                                         *
  10  *                                                                                                                                                 *
  11  *       Copyright (C) 2009 SoftPLC Corporation. http://softplc.com             *
  12  *       Dick Hollenbeck <dick@softplc.com>                                                                        *
  13  *                                                                          *
  14  *       This program is free software; you can redistribute it and/or modify   *
  15  *       it under the terms of the GNU General Public License as published by   *
  16  *       the Free Software Foundation; either version 2 of the License, or         *
  17  *       (at your option) any later version.                                                                       *
  18  *                                                                                                                                                 *
  19  *       This program is distributed in the hope that it will be useful,                   *
  20  *       but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  21  *       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  22  *       GNU General Public License for more details.                                              *
  23  *                                                                                                                                                 *
  24  *       You should have received a copy of the GNU General Public License         *
  25  *       along with this program; if not, write to the                                             *
  26  *       Free Software Foundation, Inc.,                                                                                   *
  27  *       59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.                         *
  28  ***************************************************************************/
  29
  30
  31 /* The specification for SVF is available here:
  32  * http://www.asset-intertech.com/support/svf.pdf
  33  * Below, this document is refered to as the "SVF spec".
  34  *
  35  * The specification for XSVF is available here:
  36  * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
  37  * Below, this document is refered to as the "XSVF spec".
  38  */
  39
  40 #ifdef HAVE_CONFIG_H
  41 #include "config.h"
  42 #endif
  43
  44 #include "xsvf.h"
  45
  46 #include "jtag.h"
  47 #include "command.h"
  48 #include "log.h"
  49
  50 #include <stdlib.h>
  51 #include <unistd.h>
  52 #include <sys/types.h>
  53 #include <sys/stat.h>
  54 #include <fcntl.h>
  55 #include <string.h>
  56
  57 #include <sys/time.h>
  58 #include <time.h>
  59
  60
  61 /* XSVF commands, from appendix B of xapp503.pdf  */
  62 #define XCOMPLETE               0x00
  63 #define XTDOMASK                        0x01
  64 #define XSIR                            0x02
  65 #define XSDR                            0x03
  66 #define XRUNTEST                        0x04
  67 #define XREPEAT                 0x07
  68 #define XSDRSIZE                        0x08
  69 #define XSDRTDO                 0x09
  70 #define XSETSDRMASKS            0x0A
  71 #define XSDRINC                 0x0B
  72 #define XSDRB                   0x0C
  73 #define XSDRC                   0x0D
  74 #define XSDRE                   0x0E
  75 #define XSDRTDOB                        0x0F
  76 #define XSDRTDOC                        0x10
  77 #define XSDRTDOE                        0x11
  78 #define XSTATE                  0x12
  79 #define XENDIR                  0x13
  80 #define XENDDR                  0x14
  81 #define XSIR2                   0x15
  82 #define XCOMMENT                        0x16
  83 #define XWAIT                   0x17
  84
  85 /* XWAITSTATE is not in the xilinx XSVF spec, but the svf2xsvf.py translator
  86  * generates this.  Arguably it is needed because the XSVF XRUNTEST command
  87  * was ill conceived and does not directly flow out of the SVF RUNTEST command.
  88  * This XWAITSTATE does map directly from the SVF RUNTEST command.
  89  */
  90 #define XWAITSTATE              0x18
  91
  92 /* Lattice has extended the SVF file format, and Dick Hollenbeck's python based
  93  * SVF2XSVF converter supports these 3 additional XSVF opcodes, LCOUNT, LDELAY, LSDR.
  94  * Here is an example of usage of the 3 lattice opcode extensions:
  95
  96 ! Set the maximum loop count to 25.
  97 LCOUNT  25;
  98 ! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.
  99 LDELAY  DRPAUSE 5 TCK   1.00E-003 SEC;
 100 ! Test for the completed status. Match means pass.
 101 ! Loop back to LDELAY line if not match and loop count less than 25.
 102
 103 LSDR 1  TDI  (0)
 104                 TDO  (1);
 105 */
 106
 107 #define LCOUNT                  0x19
 108 #define LDELAY                  0x1A
 109 #define LSDR                            0x1B
 110 #define XTRST                   0x1C
 111
 112
 113 /* XSVF valid state values for the XSTATE command, from appendix B of xapp503.pdf */
 114 #define XSV_RESET               0x00
 115 #define XSV_IDLE                        0x01
 116 #define XSV_DRSELECT            0x02
 117 #define XSV_DRCAPTURE   0x03
 118 #define XSV_DRSHIFT             0x04
 119 #define XSV_DREXIT1             0x05
 120 #define XSV_DRPAUSE             0x06
 121 #define XSV_DREXIT2             0x07
 122 #define XSV_DRUPDATE            0x08
 123 #define XSV_IRSELECT            0x09
 124 #define XSV_IRCAPTURE   0x0A
 125 #define XSV_IRSHIFT             0x0B
 126 #define XSV_IREXIT1             0x0C
 127 #define XSV_IRPAUSE             0x0D
 128 #define XSV_IREXIT2             0x0E
 129 #define XSV_IRUPDATE            0x0F
 130
 131 /* arguments to XTRST */
 132 #define XTRST_ON                        0
 133 #define XTRST_OFF               1
 134 #define XTRST_Z                 2
 135 #define XTRST_ABSENT            3
 136
 137 #define XSTATE_MAX_PATH 12
 138
 139 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 140
 141 static int xsvf_fd = 0;
 142
 143
 144 /* map xsvf tap state to an openocd "tap_state_t" */
 145 static tap_state_t xsvf_to_tap( int xsvf_state )
 146 {
 147         tap_state_t     ret;
 148
 149         switch( xsvf_state )
 150         {
 151         case XSV_RESET:                 ret = TAP_RESET;                        break;
 152         case XSV_IDLE:                  ret = TAP_IDLE;                 break;
 153         case XSV_DRSELECT:              ret = TAP_DRSELECT;             break;
 154         case XSV_DRCAPTURE:             ret = TAP_DRCAPTURE;            break;
 155         case XSV_DRSHIFT:               ret = TAP_DRSHIFT;              break;
 156         case XSV_DREXIT1:               ret = TAP_DREXIT1;              break;
 157         case XSV_DRPAUSE:               ret = TAP_DRPAUSE;              break;
 158         case XSV_DREXIT2:               ret = TAP_DREXIT2;              break;
 159         case XSV_DRUPDATE:              ret = TAP_DRUPDATE;             break;
 160         case XSV_IRSELECT:              ret = TAP_IRSELECT;             break;
 161         case XSV_IRCAPTURE:             ret = TAP_IRCAPTURE;            break;
 162         case XSV_IRSHIFT:               ret = TAP_IRSHIFT;              break;
 163         case XSV_IREXIT1:               ret = TAP_IREXIT1;              break;
 164         case XSV_IRPAUSE:               ret = TAP_IRPAUSE;              break;
 165         case XSV_IREXIT2:               ret = TAP_IREXIT2;              break;
 166         case XSV_IRUPDATE:              ret = TAP_IRUPDATE;             break;
 167         default:
 168                 LOG_ERROR( "UNKNOWN XSVF STATE 0x%02X", xsvf_state );
 169                 exit(1);
 170         }
 171
 172         return ret;
 173 }
 174
 175
 176 /* 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_get_tms_path(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_state_transition(curstate, true);
 205                 }
 206                 else
 207                 {
 208                         curstate = tap_state_transition(curstate, false);
 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, tap_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 mismatch, xsdrsize=%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
 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, tap_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                         if (read(xsvf_fd, &uc, 1) < 0)
 624                         {
 625                                 do_abort = 1;
 626                                 break;
 627                         }
 628
 629                         /* see page 22 of XSVF spec */
 630                         if( uc == 0 )
 631                                 xendir = TAP_IDLE;
 632                         else if( uc == 1 )
 633                                 xendir = TAP_IRPAUSE;
 634                         else
 635                         {
 636                                 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
 637                                 unsupported = 1;
 638                                 break;
 639                         }
 640
 641                         LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
 642                         break;
 643
 644                 case XENDDR:
 645
 646                         if (read(xsvf_fd, &uc, 1) < 0)
 647                         {
 648                                 do_abort = 1;
 649                                 break;
 650                         }
 651
 652                         /* see page 22 of XSVF spec */
 653                         if( uc == 0 )
 654                                 xenddr = TAP_IDLE;
 655                         else if( uc == 1 )
 656                                 xenddr = TAP_DRPAUSE;
 657                         else
 658                         {
 659                                 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
 660                                 unsupported = 1;
 661                                 break;
 662                         }
 663
 664                         LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
 665                         break;
 666
 667                 case XSIR:
 668                 case XSIR2:
 669                         {
 670                                 u8      short_buf[2];
 671                                 u8*     ir_buf;
 672                                 int bitcount;
 673                                 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
 674
 675                                 if( opcode == XSIR )
 676                                 {
 677                                         /* one byte bitcount */
 678                                         if (read(xsvf_fd, short_buf, 1) < 0)
 679                                         {
 680                                                 do_abort = 1;
 681                                                 break;
 682                                         }
 683                                         bitcount = short_buf[0];
 684                                         LOG_DEBUG("XSIR %d", bitcount);
 685                                 }
 686                                 else
 687                                 {
 688                                         if (read(xsvf_fd, short_buf, 2) < 0)
 689                                         {
 690                                                 do_abort = 1;
 691                                                 break;
 692                                         }
 693                                         bitcount = be_to_h_u16(short_buf);
 694                                         LOG_DEBUG("XSIR2 %d", bitcount);
 695                                 }
 696
 697                                 ir_buf = malloc((bitcount+7) / 8);
 698
 699                                 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
 700                                         do_abort = 1;
 701                                 else
 702                                 {
 703                                         scan_field_t field;
 704
 705                                         field.tap = tap;
 706                                         field.num_bits = bitcount;
 707                                         field.out_value = ir_buf;
 708
 709                                         field.in_value = NULL;
 710
 711
 712                                         field.in_handler = NULL;
 713
 714
 715                                         if (tap == NULL)
 716                                                 jtag_add_plain_ir_scan(1, &field, my_end_state);
 717                                         else
 718                                                 jtag_add_ir_scan(1, &field, my_end_state);
 719
 720                                         if (xruntest)
 721                                         {
 722                                                 if (runtest_requires_tck)
 723                                                         jtag_add_clocks(xruntest);
 724                                                 else
 725                                                         jtag_add_sleep(xruntest);
 726                                         }
 727
 728                                         /* Note that an -irmask of non-zero in your config file
 729                                          * can cause this to fail.  Setting -irmask to zero cand work
 730                                          * around the problem.
 731                                          */
 732
 733                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 734                                         result = jtag_execute_queue();
 735                                         if(result != ERROR_OK)
 736                                         {
 737                                                 tdo_mismatch = 1;
 738                                         }
 739                                 }
 740                                 free(ir_buf);
 741                         }
 742                         break;
 743
 744                 case XCOMMENT:
 745                         {
 746                                 unsigned int ndx = 0;
 747                                 char    comment[128];
 748
 749                                 do
 750                                 {
 751                                         if (read(xsvf_fd, &uc, 1) < 0)
 752                                         {
 753                                                 do_abort = 1;
 754                                                 break;
 755                                         }
 756
 757                                         if ( ndx < sizeof(comment)-1 )
 758                                                 comment[ndx++] = uc;
 759
 760                                 } while (uc != 0);
 761
 762                                 comment[sizeof(comment)-1] = 0;         /* regardless, terminate */
 763                                 if (verbose)
 764                                         LOG_USER("%s", comment);
 765                         }
 766                         break;
 767
 768                 case XWAIT:
 769                         {
 770                                 /* expected in stream:
 771                                    XWAIT <u8 wait_state> <u8 end_state> <u32 usecs>
 772                                 */
 773
 774                                 u8      wait;
 775                                 u8      end;
 776                                 u8      delay_buf[4];
 777
 778                                 tap_state_t wait_state;
 779                                 tap_state_t end_state;
 780                                 int     delay;
 781
 782                                 if ( read(xsvf_fd, &wait, 1) < 0
 783                                   || read(xsvf_fd, &end, 1) < 0
 784                                   || read(xsvf_fd, delay_buf, 4) < 0)
 785                                 {
 786                                         do_abort = 1;
 787                                         break;
 788                                 }
 789
 790                                 wait_state = xsvf_to_tap(wait);
 791                                 end_state  = xsvf_to_tap(end);
 792                                 delay      = be_to_h_u32(delay_buf);
 793
 794                                 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
 795
 796                                 if (runtest_requires_tck && wait_state == TAP_IDLE )
 797                                 {
 798                                         jtag_add_runtest(delay, end_state);
 799                                 }
 800                                 else
 801                                 {
 802                                         xsvf_add_statemove( wait_state );
 803                                         jtag_add_sleep(delay);
 804                                         xsvf_add_statemove( end_state );
 805                                 }
 806                         }
 807                         break;
 808
 809                 case XWAITSTATE:
 810                         {
 811                                 /* expected in stream:
 812                                    XWAITSTATE <u8 wait_state> <u8 end_state> <u32 clock_count> <u32 usecs>
 813                                 */
 814
 815                                 u8  clock_buf[4];
 816                                 u8      usecs_buf[4];
 817                                 u8      wait;
 818                                 u8      end;
 819                                 tap_state_t wait_state;
 820                                 tap_state_t end_state;
 821                                 int clock_count;
 822                                 int usecs;
 823
 824                                 if ( read(xsvf_fd, &wait, 1) < 0
 825                                  ||  read(xsvf_fd, &end, 1) < 0
 826                                  ||  read(xsvf_fd, clock_buf, 4) < 0
 827                                  ||  read(xsvf_fd, usecs_buf, 4) < 0 )
 828                                 {
 829                                         do_abort = 1;
 830                                         break;
 831                                 }
 832
 833                                 wait_state = xsvf_to_tap( wait );
 834                                 end_state  = xsvf_to_tap( end );
 835
 836                                 clock_count = be_to_h_u32(clock_buf);
 837                                 usecs       = be_to_h_u32(usecs_buf);
 838
 839                                 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
 840                                         tap_state_name(wait_state),
 841                                         tap_state_name(end_state),
 842                                         clock_count, usecs);
 843
 844                                 /* the following states are 'stable', meaning that they have a transition
 845                                  * in the state diagram back to themselves.  This is necessary because we will
 846                                  * be issuing a number of clocks in this state.  This set of allowed states is also
 847                                  * determined by the SVF RUNTEST command's allowed states.
 848                                  */
 849                                 if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE)
 850                                 {
 851                                         LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state ));
 852                                         unsupported = 1;
 853                                 }
 854
 855                                 xsvf_add_statemove( wait_state );
 856
 857                                 jtag_add_clocks( clock_count );
 858
 859                                 jtag_add_sleep( usecs );
 860
 861                                 xsvf_add_statemove( end_state );
 862                         }
 863                         break;
 864
 865                 case LCOUNT:
 866                         {
 867                                 /* expected in stream:
 868                                    LCOUNT <u32 loop_count>
 869                                 */
 870                                 u8  count_buf[4];
 871
 872                                 if ( read(xsvf_fd, count_buf, 4) < 0 )
 873                                 {
 874                                         do_abort = 1;
 875                                         break;
 876                                 }
 877
 878                                 loop_count = be_to_h_u32(count_buf);
 879                                 LOG_DEBUG("LCOUNT %d", loop_count);
 880                         }
 881                         break;
 882
 883                 case LDELAY:
 884                         {
 885                                 /* expected in stream:
 886                                    LDELAY <u8 wait_state> <u32 clock_count> <u32 usecs_to_sleep>
 887                                 */
 888                                 u8      state;
 889                                 u8  clock_buf[4];
 890                                 u8  usecs_buf[4];
 891
 892                                 if ( read(xsvf_fd, &state, 1) < 0
 893                                   || read(xsvf_fd, clock_buf, 4) < 0
 894                                   ||     read(xsvf_fd, usecs_buf, 4) < 0 )
 895                                 {
 896                                         do_abort = 1;
 897                                         break;
 898                                 }
 899
 900                                 loop_state  = xsvf_to_tap(state);
 901                                 loop_clocks = be_to_h_u32(clock_buf);
 902                                 loop_usecs  = be_to_h_u32(usecs_buf);
 903
 904                                 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
 905                         }
 906                         break;
 907
 908                 /* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
 909                  * comes with clocks !AND! sleep requirements.
 910                  */
 911                 case LSDR:
 912                         {
 913                                 int limit = loop_count;
 914                                 int matched = 0;
 915                                 int attempt;
 916
 917                                 LOG_DEBUG("LSDR");
 918
 919                                 if ( xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
 920                                   || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
 921                                 {
 922                                         do_abort = 1;
 923                                         break;
 924                                 }
 925
 926                                 if (limit < 1)
 927                                         limit = 1;
 928
 929                                 for( attempt=0; attempt<limit;  ++attempt )
 930                                 {
 931                                         scan_field_t field;
 932
 933                                         xsvf_add_statemove( loop_state );
 934                                         jtag_add_clocks(loop_clocks);
 935                                         jtag_add_sleep(loop_usecs);
 936
 937                                         field.tap = tap;
 938                                         field.num_bits = xsdrsize;
 939                                         field.out_value = dr_out_buf;
 940
 941                                         field.in_value = NULL;
 942
 943                                         if (attempt > 0 && verbose)
 944                                                 LOG_USER("LSDR retry %d", attempt);
 945
 946                                         jtag_set_check_value(&field, dr_in_buf, dr_in_mask, NULL);
 947                                         if (tap == NULL)
 948                                                 jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
 949                                         else
 950                                                 jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
 951
 952                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 953                                         result = jtag_execute_queue();
 954                                         if(result == ERROR_OK)
 955                                         {
 956                                                 matched = 1;
 957                                                 break;
 958                                         }
 959                                 }
 960
 961                                 if (!matched )
 962                                 {
 963                                         LOG_USER( "LSDR mismatch" );
 964                                         tdo_mismatch = 1;
 965                                         break;
 966                                 }
 967                         }
 968                         break;
 969
 970                 case XTRST:
 971                         {
 972                                 u8      trst_mode;
 973
 974                                 if (read(xsvf_fd, &trst_mode, 1) < 0)
 975                                 {
 976                                         do_abort = 1;
 977                                         break;
 978                                 }
 979
 980                                 switch( trst_mode )
 981                                 {
 982                                 case XTRST_ON:
 983                                         jtag_add_reset(1, 0);
 984                                         break;
 985                                 case XTRST_OFF:
 986                                 case XTRST_Z:
 987                                         jtag_add_reset(0, 0);
 988                                         break;
 989                                 case XTRST_ABSENT:
 990                                         break;
 991                                 default:
 992                                         LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode );
 993                                         do_abort = 1;
 994                                 }
 995                         }
 996                         break;
 997
 998                 default:
 999                         LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
1000                         unsupported = 1;
1001                 }
1002
1003                 if (do_abort || unsupported || tdo_mismatch)
1004                 {
1005                         LOG_DEBUG("xsvf failed, setting taps to reasonable state");
1006
1007                         /* upon error, return the TAPs to a reasonable state */
1008                         xsvf_add_statemove( TAP_IDLE );
1009                         jtag_execute_queue();
1010                         break;
1011                 }
1012         }
1013
1014         if (tdo_mismatch)
1015         {
1016                 command_print(cmd_ctx, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1017                                           file_offset );
1018
1019
1020                 return ERROR_FAIL;
1021         }
1022
1023         if (unsupported)
1024         {
1025                 command_print(cmd_ctx,
1026                          "unsupported xsvf command: 0x%02X in xsvf file at offset %ld, aborting",
1027                                           uc,  lseek(xsvf_fd, 0, SEEK_CUR)-1 );
1028                 return ERROR_FAIL;
1029         }
1030
1031         if (do_abort)
1032         {
1033                 command_print(cmd_ctx, "premature end of xsvf file detected, aborting");
1034                 return ERROR_FAIL;
1035         }
1036
1037         if (dr_out_buf)
1038                 free(dr_out_buf);
1039
1040         if (dr_in_buf)
1041                 free(dr_in_buf);
1042
1043         if (dr_in_mask)
1044                 free(dr_in_mask);
1045
1046         close(xsvf_fd);
1047
1048         command_print(cmd_ctx, "XSVF file programmed successfully");
1049
1050         return ERROR_OK;
1051 }
1052
1053
1054 #if 0   /* this comment style used to try and keep uncrustify from adding * at begin of line */
1055
1056 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
1057
1058 the following pseudo code clarifies the intent of the xrepeat support.  The
1059 flow given is for the entire processing of an SVF file, not an XSVF file.
1060 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1061
1062 "Pseudo-Code Algorithm for SVF-Based ISP"
1063
1064 1. Go to Test-Logic-Reset state
1065 2. Go to Run-Test Idle state
1066 3. Read SVF record
1067
1068 4. if SIR record then
1069            go to Shift-IR state
1070            Scan in <TDI value>
1071
1072 5. else if SDR record then
1073            set <repeat count> to 0
1074            store <TDI value> as <current TDI value>
1075            store <TDO value> as <current TDO value>
1076 6. go to Shift-DR state
1077            scan in <current TDI value>
1078            if <current TDO value> is specified then
1079                    if <current TDO value> does not equal <actual TDO value> then
1080                            if <repeat count> > 32 then
1081                                    LOG ERROR
1082                                    go to Run-Test Idle state
1083                                    go to Step 3
1084                            end if
1085                            go to Pause-DR
1086                            go to Exit2-DR
1087                            go to Shift-DR
1088                            go to Exit1-DR
1089                            go to Update-DR
1090                            go to Run-Test/Idle
1091                            increment <repeat count> by 1
1092                            pause <current pause time> microseconds
1093                            go to Step 6)
1094                    end if
1095            else
1096                    go to Run-Test Idle state
1097                    go to Step 3
1098            endif
1099 else if RUNTEST record then
1100    pause tester for <TCK value> microseconds
1101    store <TCK value> as <current pause time>
1102 end if
1103
1104 #endif