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