git.sur5r.net Git - openocd/blob - src/xsvf/xsvf.c

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