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