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