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