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

   1 /*
   2  * Copyright (C) 2005 by Dominic Rath
   3  * Dominic.Rath@gmx.de
   4  *
   5  * Copyright (C) 2007,2008 Øyvind Harboe
   6  * oyvind.harboe@zylin.com
   7  *
   8  * Copyright (C) 2008 Peter Hettkamp
   9  * peter.hettkamp@htp-tel.de
  10  *
  11  * Copyright (C) 2009 SoftPLC Corporation. http://softplc.com
  12  * Dick Hollenbeck <dick@softplc.com>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the 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         int             runtest_requires_tck = 0;       /* a flag telling whether to clock TCK during waits, or simply sleep, controled by virt2 */
 217
 218
 219         /* use NULL to indicate a "plain" xsvf file which accounts for
 220            additional devices in the scan chain, otherwise the device
 221            that should be affected
 222         */
 223         jtag_tap_t *tap = NULL;
 224
 225         if (argc < 2)
 226         {
 227                 command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
 228                 return ERROR_FAIL;
 229         }
 230
 231         filename = args[1];             /* we mess with args starting point below, snapshot filename here */
 232
 233         if (strcmp(args[0], "plain") != 0)
 234         {
 235                 tap = jtag_tap_by_string(args[0]);
 236                 if (!tap)
 237                 {
 238                         command_print(cmd_ctx, "Tap: %s unknown", args[0]);
 239                         return ERROR_FAIL;
 240                 }
 241         }
 242
 243         if ((xsvf_fd = open(filename, O_RDONLY)) < 0)
 244         {
 245                 command_print(cmd_ctx, "file \"%s\" not found", filename);
 246                 return ERROR_FAIL;
 247         }
 248
 249         /* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
 250         if ((argc > 2) && (strcmp(args[2], "virt2") == 0))
 251         {
 252                 runtest_requires_tck = 1;
 253                 --argc;
 254                 ++args;
 255         }
 256
 257         if ((argc > 2) && (strcmp(args[2], "quiet") == 0))
 258         {
 259                 verbose = 0;
 260         }
 261
 262         LOG_USER("xsvf processing file: \"%s\"", filename);
 263
 264         while (read(xsvf_fd, &opcode, 1) > 0)
 265         {
 266                 /* record the position of the just read opcode within the file */
 267                 file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
 268
 269                 switch (opcode)
 270                 {
 271                 case XCOMPLETE:
 272                         LOG_DEBUG("XCOMPLETE");
 273
 274                         result = jtag_execute_queue();
 275                         if (result != ERROR_OK)
 276                         {
 277                                 tdo_mismatch = 1;
 278                                 break;
 279                         }
 280                         break;
 281
 282                 case XTDOMASK:
 283                         LOG_DEBUG("XTDOMASK");
 284                         if (dr_in_mask && (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
 285                                 do_abort = 1;
 286                         break;
 287
 288                 case XRUNTEST:
 289                         {
 290                                 uint8_t xruntest_buf[4];
 291
 292                                 if (read(xsvf_fd, xruntest_buf, 4) < 0)
 293                                 {
 294                                         do_abort = 1;
 295                                         break;
 296                                 }
 297
 298                                 xruntest = be_to_h_u32(xruntest_buf);
 299                                 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
 300                         }
 301                         break;
 302
 303                 case XREPEAT:
 304                         {
 305                                 uint8_t myrepeat;
 306
 307                                 if (read(xsvf_fd, &myrepeat, 1) < 0)
 308                                         do_abort = 1;
 309                                 else
 310                                 {
 311                                         xrepeat = myrepeat;
 312                                         LOG_DEBUG("XREPEAT %d", xrepeat);
 313                                 }
 314                         }
 315                         break;
 316
 317                 case XSDRSIZE:
 318                         {
 319                                 uint8_t xsdrsize_buf[4];
 320
 321                                 if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
 322                                 {
 323                                         do_abort = 1;
 324                                         break;
 325                                 }
 326
 327                                 xsdrsize = be_to_h_u32(xsdrsize_buf);
 328                                 LOG_DEBUG("XSDRSIZE %d", xsdrsize);
 329
 330                                 if (dr_out_buf) free(dr_out_buf);
 331                                 if (dr_in_buf)   free(dr_in_buf);
 332                                 if (dr_in_mask)  free(dr_in_mask);
 333
 334                                 dr_out_buf = malloc((xsdrsize + 7) / 8);
 335                                 dr_in_buf = malloc((xsdrsize + 7) / 8);
 336                                 dr_in_mask = malloc((xsdrsize + 7) / 8);
 337                         }
 338                         break;
 339
 340                 case XSDR:              /* these two are identical except for the dr_in_buf */
 341                 case XSDRTDO:
 342                         {
 343                                 int limit = xrepeat;
 344                                 int     matched = 0;
 345                                 int attempt;
 346
 347                                 const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
 348
 349                                 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
 350                                 {
 351                                         do_abort = 1;
 352                                         break;
 353                                 }
 354
 355                                 if (opcode == XSDRTDO)
 356                                 {
 357                                         if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf)  != ERROR_OK)
 358                                         {
 359                                                 do_abort = 1;
 360                                                 break;
 361                                         }
 362                                 }
 363
 364                                 if (limit < 1)
 365                                         limit = 1;
 366
 367                                 LOG_DEBUG("%s %d", op_name, xsdrsize);
 368
 369                                 for (attempt = 0; attempt < limit;  ++attempt)
 370                                 {
 371                                         scan_field_t field;
 372
 373                                         if (attempt > 0)
 374                                         {
 375                                                 /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
 376                                                    illustrated in psuedo code at end of this file.  We start from state
 377                                                    DRPAUSE:
 378                                                    go to Exit2-DR
 379                                                    go to Shift-DR
 380                                                    go to Exit1-DR
 381                                                    go to Update-DR
 382                                                    go to Run-Test/Idle
 383
 384                                                    This sequence should be harmless for other devices, and it
 385                                                    will be skipped entirely if xrepeat is set to zero.
 386                                                 */
 387
 388                                                 static tap_state_t exception_path[] = {
 389                                                         TAP_DREXIT2,
 390                                                         TAP_DRSHIFT,
 391                                                         TAP_DREXIT1,
 392                                                         TAP_DRUPDATE,
 393                                                         TAP_IDLE,
 394                                                 };
 395
 396                                                 jtag_add_pathmove(DIM(exception_path), exception_path);
 397
 398                                                 if (verbose)
 399                                                         LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name, xsdrsize, attempt);
 400                                         }
 401
 402                                         field.tap = tap;
 403                                         field.num_bits = xsdrsize;
 404                                         field.out_value = dr_out_buf;
 405                                         field.in_value = calloc(CEIL(field.num_bits, 8), 1);
 406
 407                                         if (tap == NULL)
 408                                                 jtag_add_plain_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 409                                         else
 410                                                 jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 411
 412                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 413
 414                                         free(field.in_value);
 415
 416
 417                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 418                                         result = jtag_execute_queue();
 419                                         if (result == ERROR_OK)
 420                                         {
 421                                                 matched = 1;
 422                                                 break;
 423                                         }
 424                                 }
 425
 426                                 if (!matched)
 427                                 {
 428                                         LOG_USER("%s mismatch", op_name);
 429                                         tdo_mismatch = 1;
 430                                         break;
 431                                 }
 432
 433                                 /* See page 19 of XSVF spec regarding opcode "XSDR" */
 434                                 if (xruntest)
 435                                 {
 436                                         result = svf_add_statemove(TAP_IDLE);
 437
 438                                         if (runtest_requires_tck)
 439                                                 jtag_add_clocks(xruntest);
 440                                         else
 441                                                 jtag_add_sleep(xruntest);
 442                                 }
 443                                 else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
 444                                         result = svf_add_statemove(xenddr);
 445                         }
 446                         break;
 447
 448                 case XSETSDRMASKS:
 449                         LOG_ERROR("unsupported XSETSDRMASKS\n");
 450                         unsupported = 1;
 451                         break;
 452
 453                 case XSDRINC:
 454                         LOG_ERROR("unsupported XSDRINC\n");
 455                         unsupported = 1;
 456                         break;
 457
 458                 case XSDRB:
 459                         LOG_ERROR("unsupported XSDRB\n");
 460                         unsupported = 1;
 461                         break;
 462
 463                 case XSDRC:
 464                         LOG_ERROR("unsupported XSDRC\n");
 465                         unsupported = 1;
 466                         break;
 467
 468                 case XSDRE:
 469                         LOG_ERROR("unsupported XSDRE\n");
 470                         unsupported = 1;
 471                         break;
 472
 473                 case XSDRTDOB:
 474                         LOG_ERROR("unsupported XSDRTDOB\n");
 475                         unsupported = 1;
 476                         break;
 477
 478                 case XSDRTDOC:
 479                         LOG_ERROR("unsupported XSDRTDOC\n");
 480                         unsupported = 1;
 481                         break;
 482
 483                 case XSDRTDOE:
 484                         LOG_ERROR("unsupported XSDRTDOE\n");
 485                         unsupported = 1;
 486                         break;
 487
 488                 case XSTATE:
 489                         {
 490                                 tap_state_t     mystate;
 491                                 uint8_t                 uc;
 492
 493                                 if (read(xsvf_fd, &uc, 1) < 0)
 494                                 {
 495                                         do_abort = 1;
 496                                         break;
 497                                 }
 498
 499                                 mystate = xsvf_to_tap(uc);
 500
 501                                 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate));
 502
 503                                 /* NOTE: the current state is SVF-stable! */
 504
 505                                 /* no change == NOP */
 506                                 if (mystate == cmd_queue_cur_state
 507                                                 && mystate != TAP_RESET)
 508                                         break;
 509
 510                                 /* Hand off to SVF? */
 511                                 if (svf_tap_state_is_stable(mystate))
 512                                 {
 513                                         result = svf_add_statemove(mystate);
 514                                         if (result != ERROR_OK)
 515                                                 unsupported = 1;
 516                                         break;
 517                                 }
 518
 519                                 /*
 520                                  * A sequence of XSTATE transitions, each TAP
 521                                  * state adjacent to the previous one.
 522                                  *
 523                                  * NOTE: OpenOCD requires something that XSVF
 524                                  * doesn't:  the last TAP state in the path
 525                                  * must be stable.
 526                                  *
 527                                  * FIXME Implement path collection; submit via
 528                                  * jtag_add_pathmove() after teaching it to
 529                                  * report errors.
 530                                  */
 531                                 LOG_ERROR("XSVF: 'XSTATE %s' ... NYET",
 532                                                 tap_state_name(mystate));
 533                                 unsupported = 1;
 534                         }
 535                         break;
 536
 537                 case XENDIR:
 538
 539                         if (read(xsvf_fd, &uc, 1) < 0)
 540                         {
 541                                 do_abort = 1;
 542                                 break;
 543                         }
 544
 545                         /* see page 22 of XSVF spec */
 546                         if (uc == 0)
 547                                 xendir = TAP_IDLE;
 548                         else if (uc == 1)
 549                                 xendir = TAP_IRPAUSE;
 550                         else
 551                         {
 552                                 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
 553                                 unsupported = 1;
 554                                 break;
 555                         }
 556
 557                         LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
 558                         break;
 559
 560                 case XENDDR:
 561
 562                         if (read(xsvf_fd, &uc, 1) < 0)
 563                         {
 564                                 do_abort = 1;
 565                                 break;
 566                         }
 567
 568                         /* see page 22 of XSVF spec */
 569                         if (uc == 0)
 570                                 xenddr = TAP_IDLE;
 571                         else if (uc == 1)
 572                                 xenddr = TAP_DRPAUSE;
 573                         else
 574                         {
 575                                 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
 576                                 unsupported = 1;
 577                                 break;
 578                         }
 579
 580                         LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
 581                         break;
 582
 583                 case XSIR:
 584                 case XSIR2:
 585                         {
 586                                 uint8_t short_buf[2];
 587                                 uint8_t*        ir_buf;
 588                                 int bitcount;
 589                                 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
 590
 591                                 if (opcode == XSIR)
 592                                 {
 593                                         /* one byte bitcount */
 594                                         if (read(xsvf_fd, short_buf, 1) < 0)
 595                                         {
 596                                                 do_abort = 1;
 597                                                 break;
 598                                         }
 599                                         bitcount = short_buf[0];
 600                                         LOG_DEBUG("XSIR %d", bitcount);
 601                                 }
 602                                 else
 603                                 {
 604                                         if (read(xsvf_fd, short_buf, 2) < 0)
 605                                         {
 606                                                 do_abort = 1;
 607                                                 break;
 608                                         }
 609                                         bitcount = be_to_h_u16(short_buf);
 610                                         LOG_DEBUG("XSIR2 %d", bitcount);
 611                                 }
 612
 613                                 ir_buf = malloc((bitcount + 7) / 8);
 614
 615                                 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
 616                                         do_abort = 1;
 617                                 else
 618                                 {
 619                                         scan_field_t field;
 620
 621                                         field.tap = tap;
 622                                         field.num_bits = bitcount;
 623                                         field.out_value = ir_buf;
 624
 625                                         field.in_value = NULL;
 626
 627
 628
 629
 630                                         if (tap == NULL)
 631                                                 jtag_add_plain_ir_scan(1, &field, my_end_state);
 632                                         else
 633                                                 jtag_add_ir_scan(1, &field, my_end_state);
 634
 635                                         if (xruntest)
 636                                         {
 637                                                 if (runtest_requires_tck)
 638                                                         jtag_add_clocks(xruntest);
 639                                                 else
 640                                                         jtag_add_sleep(xruntest);
 641                                         }
 642
 643                                         /* Note that an -irmask of non-zero in your config file
 644                                          * can cause this to fail.  Setting -irmask to zero cand work
 645                                          * around the problem.
 646                                          */
 647
 648                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 649                                         result = jtag_execute_queue();
 650                                         if (result != ERROR_OK)
 651                                         {
 652                                                 tdo_mismatch = 1;
 653                                         }
 654                                 }
 655                                 free(ir_buf);
 656                         }
 657                         break;
 658
 659                 case XCOMMENT:
 660                         {
 661                                 unsigned int ndx = 0;
 662                                 char    comment[128];
 663
 664                                 do
 665                                 {
 666                                         if (read(xsvf_fd, &uc, 1) < 0)
 667                                         {
 668                                                 do_abort = 1;
 669                                                 break;
 670                                         }
 671
 672                                         if (ndx < sizeof(comment)-1)
 673                                                 comment[ndx++] = uc;
 674
 675                                 } while (uc != 0);
 676
 677                                 comment[sizeof(comment)-1] = 0;         /* regardless, terminate */
 678                                 if (verbose)
 679                                         LOG_USER("# %s", comment);
 680                         }
 681                         break;
 682
 683                 case XWAIT:
 684                         {
 685                                 /* expected in stream:
 686                                    XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
 687                                 */
 688
 689                                 uint8_t wait;
 690                                 uint8_t end;
 691                                 uint8_t delay_buf[4];
 692
 693                                 tap_state_t wait_state;
 694                                 tap_state_t end_state;
 695                                 int     delay;
 696
 697                                 if (read(xsvf_fd, &wait, 1) < 0
 698                                   || read(xsvf_fd, &end, 1) < 0
 699                                   || read(xsvf_fd, delay_buf, 4) < 0)
 700                                 {
 701                                         do_abort = 1;
 702                                         break;
 703                                 }
 704
 705                                 wait_state = xsvf_to_tap(wait);
 706                                 end_state  = xsvf_to_tap(end);
 707                                 delay      = be_to_h_u32(delay_buf);
 708
 709                                 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
 710
 711                                 if (runtest_requires_tck && wait_state == TAP_IDLE)
 712                                 {
 713                                         jtag_add_runtest(delay, end_state);
 714                                 }
 715                                 else
 716                                 {
 717                                         /* FIXME handle statemove errors ... */
 718                                         result = svf_add_statemove(wait_state);
 719                                         jtag_add_sleep(delay);
 720                                         result = svf_add_statemove(end_state);
 721                                 }
 722                         }
 723                         break;
 724
 725                 case XWAITSTATE:
 726                         {
 727                                 /* expected in stream:
 728                                    XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count> <uint32_t usecs>
 729                                 */
 730
 731                                 uint8_t  clock_buf[4];
 732                                 uint8_t usecs_buf[4];
 733                                 uint8_t wait;
 734                                 uint8_t end;
 735                                 tap_state_t wait_state;
 736                                 tap_state_t end_state;
 737                                 int clock_count;
 738                                 int usecs;
 739
 740                                 if (read(xsvf_fd, &wait, 1) < 0
 741                                  ||  read(xsvf_fd, &end, 1) < 0
 742                                  ||  read(xsvf_fd, clock_buf, 4) < 0
 743                                  ||  read(xsvf_fd, usecs_buf, 4) < 0)
 744                                 {
 745                                         do_abort = 1;
 746                                         break;
 747                                 }
 748
 749                                 wait_state = xsvf_to_tap(wait);
 750                                 end_state  = xsvf_to_tap(end);
 751
 752                                 clock_count = be_to_h_u32(clock_buf);
 753                                 usecs       = be_to_h_u32(usecs_buf);
 754
 755                                 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
 756                                         tap_state_name(wait_state),
 757                                         tap_state_name(end_state),
 758                                         clock_count, usecs);
 759
 760                                 /* the following states are 'stable', meaning that they have a transition
 761                                  * in the state diagram back to themselves.  This is necessary because we will
 762                                  * be issuing a number of clocks in this state.  This set of allowed states is also
 763                                  * determined by the SVF RUNTEST command's allowed states.
 764                                  */
 765                                 if (!svf_tap_state_is_stable(wait_state))
 766                                 {
 767                                         LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"",
 768                                                         tap_state_name(wait_state));
 769                                         unsupported = 1;
 770                                         /* REVISIT "break" so we won't run? */
 771                                 }
 772
 773                                 /* FIXME handle statemove errors ... */
 774                                 result = svf_add_statemove(wait_state);
 775
 776                                 jtag_add_clocks(clock_count);
 777
 778                                 jtag_add_sleep(usecs);
 779
 780                                 result = svf_add_statemove(end_state);
 781                         }
 782                         break;
 783
 784                 case LCOUNT:
 785                         {
 786                                 /* expected in stream:
 787                                    LCOUNT <uint32_t loop_count>
 788                                 */
 789                                 uint8_t  count_buf[4];
 790
 791                                 if (read(xsvf_fd, count_buf, 4) < 0)
 792                                 {
 793                                         do_abort = 1;
 794                                         break;
 795                                 }
 796
 797                                 loop_count = be_to_h_u32(count_buf);
 798                                 LOG_DEBUG("LCOUNT %d", loop_count);
 799                         }
 800                         break;
 801
 802                 case LDELAY:
 803                         {
 804                                 /* expected in stream:
 805                                    LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
 806                                 */
 807                                 uint8_t state;
 808                                 uint8_t  clock_buf[4];
 809                                 uint8_t  usecs_buf[4];
 810
 811                                 if (read(xsvf_fd, &state, 1) < 0
 812                                   || read(xsvf_fd, clock_buf, 4) < 0
 813                                   ||     read(xsvf_fd, usecs_buf, 4) < 0)
 814                                 {
 815                                         do_abort = 1;
 816                                         break;
 817                                 }
 818
 819                                 /* NOTE:  loop_state must be stable! */
 820                                 loop_state  = xsvf_to_tap(state);
 821                                 loop_clocks = be_to_h_u32(clock_buf);
 822                                 loop_usecs  = be_to_h_u32(usecs_buf);
 823
 824                                 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
 825                         }
 826                         break;
 827
 828                 /* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
 829                  * comes with clocks !AND! sleep requirements.
 830                  */
 831                 case LSDR:
 832                         {
 833                                 int limit = loop_count;
 834                                 int matched = 0;
 835                                 int attempt;
 836
 837                                 LOG_DEBUG("LSDR");
 838
 839                                 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
 840                                   || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK)
 841                                 {
 842                                         do_abort = 1;
 843                                         break;
 844                                 }
 845
 846                                 if (limit < 1)
 847                                         limit = 1;
 848
 849                                 for (attempt = 0; attempt < limit;  ++attempt)
 850                                 {
 851                                         scan_field_t field;
 852
 853                                         result = svf_add_statemove(loop_state);
 854                                         jtag_add_clocks(loop_clocks);
 855                                         jtag_add_sleep(loop_usecs);
 856
 857                                         field.tap = tap;
 858                                         field.num_bits = xsdrsize;
 859                                         field.out_value = dr_out_buf;
 860                                         field.in_value = calloc(CEIL(field.num_bits, 8), 1);
 861
 862                                         if (attempt > 0 && verbose)
 863                                                 LOG_USER("LSDR retry %d", attempt);
 864
 865                                         if (tap == NULL)
 866                                                 jtag_add_plain_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 867                                         else
 868                                                 jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
 869
 870                                         jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
 871
 872                                         free(field.in_value);
 873
 874
 875                                         /* LOG_DEBUG("FLUSHING QUEUE"); */
 876                                         result = jtag_execute_queue();
 877                                         if (result == ERROR_OK)
 878                                         {
 879                                                 matched = 1;
 880                                                 break;
 881                                         }
 882                                 }
 883
 884                                 if (!matched)
 885                                 {
 886                                         LOG_USER("LSDR mismatch");
 887                                         tdo_mismatch = 1;
 888                                         break;
 889                                 }
 890                         }
 891                         break;
 892
 893                 case XTRST:
 894                         {
 895                                 uint8_t trst_mode;
 896
 897                                 if (read(xsvf_fd, &trst_mode, 1) < 0)
 898                                 {
 899                                         do_abort = 1;
 900                                         break;
 901                                 }
 902
 903                                 switch (trst_mode)
 904                                 {
 905                                 case XTRST_ON:
 906                                         jtag_add_reset(1, 0);
 907                                         break;
 908                                 case XTRST_OFF:
 909                                 case XTRST_Z:
 910                                         jtag_add_reset(0, 0);
 911                                         break;
 912                                 case XTRST_ABSENT:
 913                                         break;
 914                                 default:
 915                                         LOG_ERROR("XTRST mode argument (0x%02X) out of range", trst_mode);
 916                                         do_abort = 1;
 917                                 }
 918                         }
 919                         break;
 920
 921                 default:
 922                         LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
 923                         unsupported = 1;
 924                 }
 925
 926                 if (do_abort || unsupported || tdo_mismatch)
 927                 {
 928                         LOG_DEBUG("xsvf failed, setting taps to reasonable state");
 929
 930                         /* upon error, return the TAPs to a reasonable state */
 931                         result = svf_add_statemove(TAP_IDLE);
 932                         result = jtag_execute_queue();
 933                         break;
 934                 }
 935         }
 936
 937         if (tdo_mismatch)
 938         {
 939                 command_print(cmd_ctx, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
 940                                           file_offset);
 941
 942
 943                 return ERROR_FAIL;
 944         }
 945
 946         if (unsupported)
 947         {
 948                 off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
 949                 command_print(cmd_ctx,
 950                                 "unsupported xsvf command (0x%02X) at offset %jd, aborting",
 951                                 uc, (intmax_t)offset);
 952                 return ERROR_FAIL;
 953         }
 954
 955         if (do_abort)
 956         {
 957                 command_print(cmd_ctx, "premature end of xsvf file detected, aborting");
 958                 return ERROR_FAIL;
 959         }
 960
 961         if (dr_out_buf)
 962                 free(dr_out_buf);
 963
 964         if (dr_in_buf)
 965                 free(dr_in_buf);
 966
 967         if (dr_in_mask)
 968                 free(dr_in_mask);
 969
 970         close(xsvf_fd);
 971
 972         command_print(cmd_ctx, "XSVF file programmed successfully");
 973
 974         return ERROR_OK;
 975 }
 976
 977
 978 #if 0   /* this comment style used to try and keep uncrustify from adding * at begin of line */
 979
 980 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
 981
 982 the following pseudo code clarifies the intent of the xrepeat support.  The
 983 flow given is for the entire processing of an SVF file, not an XSVF file.
 984 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
 985
 986 "Pseudo-Code Algorithm for SVF-Based ISP"
 987
 988 1. Go to Test-Logic-Reset state
 989 2. Go to Run-Test Idle state
 990 3. Read SVF record
 991
 992 4. if SIR record then
 993            go to Shift-IR state
 994            Scan in <TDI value>
 995
 996 5. else if SDR record then
 997            set <repeat count> to 0
 998            store <TDI value> as <current TDI value>
 999            store <TDO value> as <current TDO value>
1000 6. go to Shift-DR state
1001            scan in <current TDI value>
1002            if <current TDO value> is specified then
1003                    if <current TDO value> does not equal <actual TDO value> then
1004                            if <repeat count> > 32 then
1005                                    LOG ERROR
1006                                    go to Run-Test Idle state
1007                                    go to Step 3
1008                            end if
1009                            go to Pause-DR
1010                            go to Exit2-DR
1011                            go to Shift-DR
1012                            go to Exit1-DR
1013                            go to Update-DR
1014                            go to Run-Test/Idle
1015                            increment <repeat count> by 1
1016                            pause <current pause time> microseconds
1017                            go to Step 6)
1018                    end if
1019            else
1020                    go to Run-Test Idle state
1021                    go to Step 3
1022            endif
1023 else if RUNTEST record then
1024    pause tester for <TCK value> microseconds
1025    store <TCK value> as <current pause time>
1026 end if
1027
1028 #endif