git.gag.com Git - fw/openocd/blob - src/xsvf/xsvf.c

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