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