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