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