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

   1 /***************************************************************************
   2  *       Copyright (C) 2009 by Simon Qian                                                                          *
   3  *       SimonQian@SimonQian.com                                                                                           *
   4  *                                                                         *
   5  *       This program is free software; you can redistribute it and/or modify  *
   6  *       it under the terms of the GNU General Public License as published by  *
   7  *       the Free Software Foundation; either version 2 of the License, or         *
   8  *       (at your option) any later version.                                                               *
   9  *                                                                                                                                                 *
  10  *       This program is distributed in the hope that it will be useful,           *
  11  *       but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  12  *       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  13  *       GNU General Public License for more details.                                              *
  14  *                                                                                                                                                 *
  15  *       You should have received a copy of the GNU General Public License         *
  16  *       along with this program; if not, write to the                                             *
  17  *       Free Software Foundation, Inc.,                                                                           *
  18  *       59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.                         *
  19  ***************************************************************************/
  20
  21
  22 /* The specification for SVF is available here:
  23  * http://www.asset-intertech.com/support/svf.pdf
  24  * Below, this document is refered to as the "SVF spec".
  25  *
  26  * The specification for XSVF is available here:
  27  * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
  28  * Below, this document is refered to as the "XSVF spec".
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34
  35 #include "svf.h"
  36 #include "jtag.h"
  37 #include "time_support.h"
  38
  39
  40 // SVF command
  41 typedef enum
  42 {
  43         ENDDR,
  44         ENDIR,
  45         FREQUENCY,
  46         HDR,
  47         HIR,
  48         PIO,
  49         PIOMAP,
  50         RUNTEST,
  51         SDR,
  52         SIR,
  53         STATE,
  54         TDR,
  55         TIR,
  56         TRST,
  57 }svf_command_t;
  58
  59 const char *svf_command_name[14] =
  60 {
  61         "ENDDR",
  62         "ENDIR",
  63         "FREQUENCY",
  64         "HDR",
  65         "HIR",
  66         "PIO",
  67         "PIOMAP",
  68         "RUNTEST",
  69         "SDR",
  70         "SIR",
  71         "STATE",
  72         "TDR",
  73         "TIR",
  74         "TRST"
  75 };
  76
  77 typedef enum
  78 {
  79         TRST_ON,
  80         TRST_OFF,
  81         TRST_Z,
  82         TRST_ABSENT
  83 }trst_mode_t;
  84
  85 const char *svf_trst_mode_name[4] =
  86 {
  87         "ON",
  88         "OFF",
  89         "Z",
  90         "ABSENT"
  91 };
  92
  93 typedef struct
  94 {
  95         tap_state_t from;
  96         tap_state_t to;
  97         uint32_t num_of_moves;
  98         tap_state_t paths[8];
  99 }svf_statemove_t;
 100
 101 svf_statemove_t svf_statemoves[] =
 102 {
 103         // from                 to                              num_of_moves,   paths[8]
 104 //      {TAP_RESET,             TAP_RESET,              1,                              {TAP_RESET}},
 105         {TAP_RESET,             TAP_IDLE,               2,                              {TAP_RESET, TAP_IDLE}},
 106         {TAP_RESET,             TAP_DRPAUSE,    6,                              {TAP_RESET, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
 107         {TAP_RESET,             TAP_IRPAUSE,    7,                              {TAP_RESET, TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
 108
 109 //      {TAP_IDLE,              TAP_RESET,              4,                              {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
 110         {TAP_IDLE,              TAP_IDLE,               1,                              {TAP_IDLE}},
 111         {TAP_IDLE,              TAP_DRPAUSE,    5,                              {TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
 112         {TAP_IDLE,              TAP_IRPAUSE,    6,                              {TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
 113
 114 //      {TAP_DRPAUSE,   TAP_RESET,              6,                              {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
 115         {TAP_DRPAUSE,   TAP_IDLE,               4,                              {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE}},
 116         {TAP_DRPAUSE,   TAP_DRPAUSE,    7,                              {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
 117         {TAP_DRPAUSE,   TAP_IRPAUSE,    8,                              {TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
 118
 119 //      {TAP_IRPAUSE,   TAP_RESET,              6,                              {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
 120         {TAP_IRPAUSE,   TAP_IDLE,               4,                              {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_IDLE}},
 121         {TAP_IRPAUSE,   TAP_DRPAUSE,    7,                              {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
 122         {TAP_IRPAUSE,   TAP_IRPAUSE,    8,                              {TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}}
 123 };
 124
 125 char *svf_tap_state_name[TAP_NUM_STATES];
 126
 127 #define XXR_TDI                                         (1 << 0)
 128 #define XXR_TDO                                         (1 << 1)
 129 #define XXR_MASK                                        (1 << 2)
 130 #define XXR_SMASK                                       (1 << 3)
 131 typedef struct
 132 {
 133         int len;
 134         int data_mask;
 135         uint8_t *tdi;
 136         uint8_t *tdo;
 137         uint8_t *mask;
 138         uint8_t *smask;
 139 }svf_xxr_para_t;
 140
 141 typedef struct
 142 {
 143         float frequency;
 144         tap_state_t ir_end_state;
 145         tap_state_t dr_end_state;
 146         tap_state_t runtest_run_state;
 147         tap_state_t runtest_end_state;
 148         trst_mode_t trst_mode;
 149
 150         svf_xxr_para_t hir_para;
 151         svf_xxr_para_t hdr_para;
 152         svf_xxr_para_t tir_para;
 153         svf_xxr_para_t tdr_para;
 154         svf_xxr_para_t sir_para;
 155         svf_xxr_para_t sdr_para;
 156 }svf_para_t;
 157
 158 svf_para_t svf_para;
 159 const svf_para_t svf_para_init =
 160 {
 161 //      frequency,      ir_end_state,   dr_end_state,   runtest_run_state,      runtest_end_state,      trst_mode
 162         0,                      TAP_IDLE,               TAP_IDLE,               TAP_IDLE,                       TAP_IDLE,                       TRST_Z,
 163 //      hir_para
 164 //      {len,   data_mask,      tdi,    tdo,    mask,   smask},
 165         {0,             0,                      NULL,   NULL,   NULL,   NULL},
 166 //      hdr_para
 167 //      {len,   data_mask,      tdi,    tdo,    mask,   smask},
 168         {0,             0,                      NULL,   NULL,   NULL,   NULL},
 169 //      tir_para
 170 //      {len,   data_mask,      tdi,    tdo,    mask,   smask},
 171         {0,             0,                      NULL,   NULL,   NULL,   NULL},
 172 //      tdr_para
 173 //      {len,   data_mask,      tdi,    tdo,    mask,   smask},
 174         {0,             0,                      NULL,   NULL,   NULL,   NULL},
 175 //      sir_para
 176 //      {len,   data_mask,      tdi,    tdo,    mask,   smask},
 177         {0,             0,                      NULL,   NULL,   NULL,   NULL},
 178 //      sdr_para
 179 //      {len,   data_mask,      tdi,    tdo,    mask,   smask},
 180         {0,             0,                      NULL,   NULL,   NULL,   NULL},
 181 };
 182
 183 typedef struct
 184 {
 185         int line_num;           // used to record line number of the check operation
 186                                                 // so more information could be printed
 187         int enabled;            // check is enabled or not
 188         int buffer_offset;      // buffer_offset to buffers
 189         int bit_len;            // bit length to check
 190 }svf_check_tdo_para_t;
 191
 192 #define SVF_CHECK_TDO_PARA_SIZE 1024
 193 static svf_check_tdo_para_t *svf_check_tdo_para = NULL;
 194 static int svf_check_tdo_para_index = 0;
 195
 196 #define dimof(a)                                        (sizeof(a) / sizeof((a)[0]))
 197
 198 static int svf_read_command_from_file(int fd);
 199 static int svf_check_tdo(void);
 200 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len);
 201 static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str);
 202 static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 203
 204 static int svf_fd = 0;
 205 static char *svf_command_buffer = NULL;
 206 static int svf_command_buffer_size = 0;
 207 static int svf_line_number = 1;
 208
 209 static jtag_tap_t *tap = NULL;
 210
 211 #define SVF_MAX_BUFFER_SIZE_TO_COMMIT   (4 * 1024)
 212 static uint8_t *svf_tdi_buffer = NULL, *svf_tdo_buffer = NULL, *svf_mask_buffer = NULL;
 213 static int svf_buffer_index = 0, svf_buffer_size = 0;
 214 static int svf_quiet = 0;
 215
 216
 217 int svf_register_commands(struct command_context_s *cmd_ctx)
 218 {
 219         register_command(cmd_ctx, NULL, "svf", handle_svf_command,
 220                 COMMAND_EXEC, "run svf <file>");
 221
 222         return ERROR_OK;
 223 }
 224
 225 void svf_free_xxd_para(svf_xxr_para_t *para)
 226 {
 227         if (NULL != para)
 228         {
 229                 if (para->tdi != NULL)
 230                 {
 231                         free(para->tdi);
 232                         para->tdi = NULL;
 233                 }
 234                 if (para->tdo != NULL)
 235                 {
 236                         free(para->tdo);
 237                         para->tdo = NULL;
 238                 }
 239                 if (para->mask != NULL)
 240                 {
 241                         free(para->mask);
 242                         para->mask = NULL;
 243                 }
 244                 if (para->smask != NULL)
 245                 {
 246                         free(para->smask);
 247                         para->smask = NULL;
 248                 }
 249         }
 250 }
 251
 252 unsigned svf_get_mask_u32(int bitlen)
 253 {
 254         uint32_t bitmask;
 255
 256         if (bitlen < 0)
 257         {
 258                 bitmask = 0;
 259         }
 260         else if (bitlen >= 32)
 261         {
 262                 bitmask = 0xFFFFFFFF;
 263         }
 264         else
 265         {
 266                 bitmask = (1 << bitlen) - 1;
 267         }
 268
 269         return bitmask;
 270 }
 271
 272 static const char* tap_state_svf_name(tap_state_t state)
 273 {
 274         const char* ret;
 275
 276         switch (state)
 277         {
 278         case TAP_RESET:         ret = "RESET";          break;
 279         case TAP_IDLE:          ret = "IDLE";           break;
 280         case TAP_DRSELECT:      ret = "DRSELECT";       break;
 281         case TAP_DRCAPTURE: ret = "DRCAPTURE";  break;
 282         case TAP_DRSHIFT:       ret = "DRSHIFT";        break;
 283         case TAP_DREXIT1:       ret = "DREXIT1";        break;
 284         case TAP_DRPAUSE:       ret = "DRPAUSE";        break;
 285         case TAP_DREXIT2:       ret = "DREXIT2";        break;
 286         case TAP_DRUPDATE:      ret = "DRUPDATE";       break;
 287         case TAP_IRSELECT:      ret = "IRSELECT";       break;
 288         case TAP_IRCAPTURE: ret = "IRCAPTURE";  break;
 289         case TAP_IRSHIFT:       ret = "IRSHIFT";        break;
 290         case TAP_IREXIT1:       ret = "IREXIT1";        break;
 291         case TAP_IRPAUSE:       ret = "IRPAUSE";        break;
 292         case TAP_IREXIT2:       ret = "IREXIT2";        break;
 293         case TAP_IRUPDATE:      ret = "IRUPDATE";       break;
 294         default:                        ret = "???";            break;
 295         }
 296
 297         return ret;
 298 }
 299
 300 static int svf_add_statemove(tap_state_t state_to)
 301 {
 302         tap_state_t state_from = cmd_queue_cur_state;
 303         uint8_t index;
 304
 305         for (index = 0; index < dimof(svf_statemoves); index++)
 306         {
 307                 if ((svf_statemoves[index].from == state_from)
 308                         && (svf_statemoves[index].to == state_to))
 309                 {
 310                         if (TAP_RESET == state_from)
 311                         {
 312                                 jtag_add_tlr();
 313                                 if (svf_statemoves[index].num_of_moves > 1)
 314                                 {
 315                                         jtag_add_pathmove(svf_statemoves[index].num_of_moves - 1, svf_statemoves[index].paths + 1);
 316                                 }
 317                         }
 318                         else
 319                         {
 320                                 if (svf_statemoves[index].num_of_moves > 0)
 321                                 {
 322                                         jtag_add_pathmove(svf_statemoves[index].num_of_moves, svf_statemoves[index].paths);
 323                                 }
 324                         }
 325                         return ERROR_OK;
 326                 }
 327         }
 328         LOG_ERROR("can not move to %s", tap_state_svf_name(state_to));
 329         return ERROR_FAIL;
 330 }
 331
 332 static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 333 {
 334 #define SVF_NUM_OF_OPTIONS                      1
 335         int command_num = 0, i;
 336         int ret = ERROR_OK;
 337         long long time_ago;
 338
 339         if ((argc < 1) || (argc > (1 + SVF_NUM_OF_OPTIONS)))
 340         {
 341                 command_print(cmd_ctx, "usage: svf <file> [quiet]");
 342                 return ERROR_FAIL;
 343         }
 344
 345         // parse variant
 346         svf_quiet = 0;
 347         for (i = 1; i < argc; i++)
 348         {
 349                 if (!strcmp(args[i], "quiet"))
 350                 {
 351                         svf_quiet = 1;
 352                 }
 353                 else
 354                 {
 355                         LOG_ERROR("unknown variant for svf: %s", args[i]);
 356
 357                         // no need to free anything now
 358                         return ERROR_FAIL;
 359                 }
 360         }
 361
 362         if ((svf_fd = open(args[0], O_RDONLY)) < 0)
 363         {
 364                 command_print(cmd_ctx, "file \"%s\" not found", args[0]);
 365
 366                 // no need to free anything now
 367                 return ERROR_FAIL;
 368         }
 369
 370         LOG_USER("svf processing file: \"%s\"", args[0]);
 371
 372         // get time
 373         time_ago = timeval_ms();
 374
 375         // init
 376         svf_line_number = 1;
 377         svf_command_buffer_size = 0;
 378
 379         svf_check_tdo_para_index = 0;
 380         svf_check_tdo_para = malloc(sizeof(svf_check_tdo_para_t) * SVF_CHECK_TDO_PARA_SIZE);
 381         if (NULL == svf_check_tdo_para)
 382         {
 383                 LOG_ERROR("not enough memory");
 384                 ret = ERROR_FAIL;
 385                 goto free_all;
 386         }
 387
 388         svf_buffer_index = 0;
 389         // double the buffer size
 390         // in case current command cannot be commited, and next command is a bit scan command
 391         // here is 32K bits for this big scan command, it should be enough
 392         // buffer will be reallocated if buffer size is not enough
 393         svf_tdi_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
 394         if (NULL == svf_tdi_buffer)
 395         {
 396                 LOG_ERROR("not enough memory");
 397                 ret = ERROR_FAIL;
 398                 goto free_all;
 399         }
 400         svf_tdo_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
 401         if (NULL == svf_tdo_buffer)
 402         {
 403                 LOG_ERROR("not enough memory");
 404                 ret = ERROR_FAIL;
 405                 goto free_all;
 406         }
 407         svf_mask_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
 408         if (NULL == svf_mask_buffer)
 409         {
 410                 LOG_ERROR("not enough memory");
 411                 ret = ERROR_FAIL;
 412                 goto free_all;
 413         }
 414         svf_buffer_size = 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT;
 415
 416         memcpy(&svf_para, &svf_para_init, sizeof(svf_para));
 417         for (i = 0; i < (int)dimof(svf_tap_state_name); i++)
 418         {
 419                 svf_tap_state_name[i] = (char *)tap_state_svf_name(i);
 420         }
 421
 422         // TAP_RESET
 423         jtag_add_tlr();
 424
 425         while (ERROR_OK == svf_read_command_from_file(svf_fd))
 426         {
 427                 if (ERROR_OK != svf_run_command(cmd_ctx, svf_command_buffer))
 428                 {
 429                         LOG_ERROR("fail to run command at line %d", svf_line_number);
 430                         ret = ERROR_FAIL;
 431                         break;
 432                 }
 433                 command_num++;
 434         }
 435         if (ERROR_OK != jtag_execute_queue())
 436         {
 437                 ret = ERROR_FAIL;
 438         }
 439         else if (ERROR_OK != svf_check_tdo())
 440         {
 441                 ret = ERROR_FAIL;
 442         }
 443
 444         // print time
 445         command_print(cmd_ctx, "%lld ms used", timeval_ms() - time_ago);
 446
 447 free_all:
 448
 449         close(svf_fd);
 450         svf_fd = 0;
 451
 452         // free buffers
 453         if (svf_command_buffer)
 454         {
 455                 free(svf_command_buffer);
 456                 svf_command_buffer = NULL;
 457                 svf_command_buffer_size = 0;
 458         }
 459         if (svf_check_tdo_para)
 460         {
 461                 free(svf_check_tdo_para);
 462                 svf_check_tdo_para = NULL;
 463                 svf_check_tdo_para_index = 0;
 464         }
 465         if (svf_tdi_buffer)
 466         {
 467                 free(svf_tdi_buffer);
 468                 svf_tdi_buffer = NULL;
 469         }
 470         if (svf_tdo_buffer)
 471         {
 472                 free(svf_tdo_buffer);
 473                 svf_tdo_buffer = NULL;
 474         }
 475         if (svf_mask_buffer)
 476         {
 477                 free(svf_mask_buffer);
 478                 svf_mask_buffer = NULL;
 479         }
 480         svf_buffer_index = 0;
 481         svf_buffer_size = 0;
 482
 483         svf_free_xxd_para(&svf_para.hdr_para);
 484         svf_free_xxd_para(&svf_para.hir_para);
 485         svf_free_xxd_para(&svf_para.tdr_para);
 486         svf_free_xxd_para(&svf_para.tir_para);
 487         svf_free_xxd_para(&svf_para.sdr_para);
 488         svf_free_xxd_para(&svf_para.sir_para);
 489
 490         if (ERROR_OK == ret)
 491         {
 492                 command_print(cmd_ctx, "svf file programmed successfully for %d commands", command_num);
 493         }
 494         else
 495         {
 496                 command_print(cmd_ctx, "svf file programmed failed");
 497         }
 498
 499         return ret;
 500 }
 501
 502 #define SVFP_CMD_INC_CNT                        1024
 503 static int svf_read_command_from_file(int fd)
 504 {
 505         char ch, *tmp_buffer = NULL;
 506         int cmd_pos = 0, cmd_ok = 0, slash = 0, comment = 0;
 507
 508         while (!cmd_ok && (read(fd, &ch, 1) > 0))
 509         {
 510                 switch (ch)
 511                 {
 512                 case '!':
 513                         slash = 0;
 514                         comment = 1;
 515                         break;
 516                 case '/':
 517                         if (++slash == 2)
 518                         {
 519                                 comment = 1;
 520                         }
 521                         break;
 522                 case ';':
 523                         slash = 0;
 524                         if (!comment)
 525                         {
 526                                 cmd_ok = 1;
 527                         }
 528                         break;
 529                 case '\n':
 530                         svf_line_number++;
 531                 case '\r':
 532                         slash = 0;
 533                         comment = 0;
 534                         break;
 535                 default:
 536                         if (!comment)
 537                         {
 538                                 if (cmd_pos >= svf_command_buffer_size - 1)
 539                                 {
 540                                         tmp_buffer = (char*)malloc(svf_command_buffer_size + SVFP_CMD_INC_CNT);         // 1 more byte for '\0'
 541                                         if (NULL == tmp_buffer)
 542                                         {
 543                                                 LOG_ERROR("not enough memory");
 544                                                 return ERROR_FAIL;
 545                                         }
 546                                         if (svf_command_buffer_size > 0)
 547                                         {
 548                                                 memcpy(tmp_buffer, svf_command_buffer, svf_command_buffer_size);
 549                                         }
 550                                         if (svf_command_buffer != NULL)
 551                                         {
 552                                                 free(svf_command_buffer);
 553                                         }
 554                                         svf_command_buffer = tmp_buffer;
 555                                         svf_command_buffer_size += SVFP_CMD_INC_CNT;
 556                                         tmp_buffer = NULL;
 557                                 }
 558                                 svf_command_buffer[cmd_pos++] = (char)toupper(ch);
 559                         }
 560                         break;
 561                 }
 562         }
 563
 564         if (cmd_ok)
 565         {
 566                 svf_command_buffer[cmd_pos] = '\0';
 567                 return ERROR_OK;
 568         }
 569         else
 570         {
 571                 return ERROR_FAIL;
 572         }
 573 }
 574
 575 static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
 576 {
 577         int pos = 0, num = 0, space_found = 1;
 578
 579         while (pos < len)
 580         {
 581                 switch (str[pos])
 582                 {
 583                 case '\n':
 584                 case '\r':
 585                 case '!':
 586                 case '/':
 587                         LOG_ERROR("fail to parse svf command");
 588                         return ERROR_FAIL;
 589                         break;
 590                 case ' ':
 591                         space_found = 1;
 592                         str[pos] = '\0';
 593                         break;
 594                 default:
 595                         if (space_found)
 596                         {
 597                                 argus[num++] = &str[pos];
 598                                 space_found = 0;
 599                         }
 600                         break;
 601                 }
 602                 pos++;
 603         }
 604
 605         *num_of_argu = num;
 606
 607         return ERROR_OK;
 608 }
 609
 610 static int svf_tap_state_is_stable(tap_state_t state)
 611 {
 612         return ((TAP_RESET == state) || (TAP_IDLE == state) || (TAP_DRPAUSE == state) || (TAP_IRPAUSE == state));
 613 }
 614
 615 static int svf_tap_state_is_valid(tap_state_t state)
 616 {
 617         return state >= 0 && state < TAP_NUM_STATES;
 618 }
 619
 620 static int svf_find_string_in_array(char *str, char **strs, int num_of_element)
 621 {
 622         int i;
 623
 624         for (i = 0; i < num_of_element; i++)
 625         {
 626                 if (!strcmp(str, strs[i]))
 627                 {
 628                         return i;
 629                 }
 630         }
 631         return 0xFF;
 632 }
 633
 634 static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_len)
 635 {
 636         int new_byte_len = (new_bit_len + 7) >> 3;
 637
 638         if ((NULL == *arr) || (((orig_bit_len + 7) >> 3) < ((new_bit_len + 7) >> 3)))
 639         {
 640                 if (*arr != NULL)
 641                 {
 642                         free(*arr);
 643                         *arr = NULL;
 644                 }
 645                 *arr = (uint8_t*)malloc(new_byte_len);
 646                 if (NULL == *arr)
 647                 {
 648                         LOG_ERROR("not enough memory");
 649                         return ERROR_FAIL;
 650                 }
 651                 memset(*arr, 0, new_byte_len);
 652         }
 653         return ERROR_OK;
 654 }
 655
 656 static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_len, int bit_len)
 657 {
 658         int i, str_len = strlen(str), str_hbyte_len = (bit_len + 3) >> 2;
 659         uint8_t ch;
 660
 661         if (ERROR_OK != svf_adjust_array_length(bin, orig_bit_len, bit_len))
 662         {
 663                 LOG_ERROR("fail to adjust length of array");
 664                 return ERROR_FAIL;
 665         }
 666
 667         for (i = 0; i < str_hbyte_len; i++)
 668         {
 669                 ch = 0;
 670                 while (str_len > 0)
 671                 {
 672                         ch = str[--str_len];
 673
 674                         if (!isblank(ch))
 675                         {
 676                                 if ((ch >= '0') && (ch <= '9'))
 677                                 {
 678                                         ch = ch - '0';
 679                                         break;
 680                                 }
 681                                 else if ((ch >= 'A') && (ch <= 'F'))
 682                                 {
 683                                         ch = ch - 'A' + 10;
 684                                         break;
 685                                 }
 686                                 else
 687                                 {
 688                                         LOG_ERROR("invalid hex string");
 689                                         return ERROR_FAIL;
 690                                 }
 691                         }
 692
 693                         ch = 0;
 694                 }
 695
 696                 // write bin
 697                 if (i % 2)
 698                 {
 699                         // MSB
 700                         (*bin)[i / 2] |= ch << 4;
 701                 }
 702                 else
 703                 {
 704                         // LSB
 705                         (*bin)[i / 2] = 0;
 706                         (*bin)[i / 2] |= ch;
 707                 }
 708         }
 709
 710         // check valid
 711         if (str_len > 0 || (ch & ~((1 << (4 - (bit_len % 4))) - 1)) != 0)
 712         {
 713                 LOG_ERROR("value execede length");
 714                 return ERROR_FAIL;
 715         }
 716
 717         return ERROR_OK;
 718 }
 719
 720 static int svf_check_tdo(void)
 721 {
 722         int i, len, index;
 723
 724         for (i = 0; i < svf_check_tdo_para_index; i++)
 725         {
 726                 index = svf_check_tdo_para[i].buffer_offset;
 727                 len = svf_check_tdo_para[i].bit_len;
 728                 if ((svf_check_tdo_para[i].enabled)
 729                         && buf_cmp_mask(&svf_tdi_buffer[index], &svf_tdo_buffer[index], &svf_mask_buffer[index], len))
 730                 {
 731                         unsigned bitmask;
 732                         unsigned received, expected, tapmask;
 733                         bitmask = svf_get_mask_u32(svf_check_tdo_para[i].bit_len);
 734
 735                         memcpy(&received, svf_tdi_buffer + index, sizeof(unsigned));
 736                         memcpy(&expected, svf_tdo_buffer + index, sizeof(unsigned));
 737                         memcpy(&tapmask, svf_mask_buffer + index, sizeof(unsigned));
 738                         LOG_ERROR("tdo check error at line %d",
 739                                           svf_check_tdo_para[i].line_num);
 740                         LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
 741                                           received & bitmask,
 742                                           expected & bitmask,
 743                                           tapmask & bitmask);
 744                         return ERROR_FAIL;
 745                 }
 746         }
 747         svf_check_tdo_para_index = 0;
 748
 749         return ERROR_OK;
 750 }
 751
 752 static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len)
 753 {
 754         if (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE)
 755         {
 756                 LOG_ERROR("toooooo many operation undone");
 757                 return ERROR_FAIL;
 758         }
 759
 760         svf_check_tdo_para[svf_check_tdo_para_index].line_num = svf_line_number;
 761         svf_check_tdo_para[svf_check_tdo_para_index].bit_len = bit_len;
 762         svf_check_tdo_para[svf_check_tdo_para_index].enabled = enabled;
 763         svf_check_tdo_para[svf_check_tdo_para_index].buffer_offset = buffer_offset;
 764         svf_check_tdo_para_index++;
 765
 766         return ERROR_OK;
 767 }
 768
 769 static int svf_execute_tap(void)
 770 {
 771         if (ERROR_OK != jtag_execute_queue())
 772         {
 773                 return ERROR_FAIL;
 774         }
 775         else if (ERROR_OK != svf_check_tdo())
 776         {
 777                 return ERROR_FAIL;
 778         }
 779
 780         svf_buffer_index = 0;
 781
 782         return ERROR_OK;
 783 }
 784
 785 static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str)
 786 {
 787         char *argus[256], command;
 788         int num_of_argu = 0, i;
 789
 790         // tmp variable
 791         int i_tmp;
 792
 793         // for RUNTEST
 794         int run_count;
 795         float min_time, max_time;
 796         // for XXR
 797         svf_xxr_para_t *xxr_para_tmp;
 798         uint8_t **pbuffer_tmp;
 799         scan_field_t field;
 800         // for STATE
 801         tap_state_t *path = NULL, state;
 802
 803         if (!svf_quiet)
 804         {
 805                 LOG_USER("%s", svf_command_buffer);
 806         }
 807
 808         if (ERROR_OK != svf_parse_cmd_string(cmd_str, strlen(cmd_str), argus, &num_of_argu))
 809         {
 810                 return ERROR_FAIL;
 811         }
 812
 813         command = svf_find_string_in_array(argus[0], (char **)svf_command_name, dimof(svf_command_name));
 814         switch (command)
 815         {
 816         case ENDDR:
 817         case ENDIR:
 818                 if (num_of_argu != 2)
 819                 {
 820                         LOG_ERROR("invalid parameter of %s", argus[0]);
 821                         return ERROR_FAIL;
 822                 }
 823                 i_tmp = svf_find_string_in_array(argus[1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
 824                 if (svf_tap_state_is_stable(i_tmp))
 825                 {
 826                         if (command == ENDIR)
 827                         {
 828                                 svf_para.ir_end_state = i_tmp;
 829                                 LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name[svf_para.ir_end_state]);
 830                         }
 831                         else
 832                         {
 833                                 svf_para.dr_end_state = i_tmp;
 834                                 LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name[svf_para.dr_end_state]);
 835                         }
 836                 }
 837                 else
 838                 {
 839                         LOG_ERROR("%s is not valid state", argus[1]);
 840                         return ERROR_FAIL;
 841                 }
 842                 break;
 843         case FREQUENCY:
 844                 if ((num_of_argu != 1) && (num_of_argu != 3))
 845                 {
 846                         LOG_ERROR("invalid parameter of %s", argus[0]);
 847                         return ERROR_FAIL;
 848                 }
 849                 if (1 == num_of_argu)
 850                 {
 851                         // TODO: set jtag speed to full speed
 852                         svf_para.frequency = 0;
 853                 }
 854                 else
 855                 {
 856                         if (strcmp(argus[2], "HZ"))
 857                         {
 858                                 LOG_ERROR("HZ not found in FREQUENCY command");
 859                                 return ERROR_FAIL;
 860                         }
 861                         if (ERROR_OK != svf_execute_tap())
 862                         {
 863                                 return ERROR_FAIL;
 864                         }
 865                         svf_para.frequency = atof(argus[1]);
 866                         // TODO: set jtag speed to
 867                         if (svf_para.frequency > 0)
 868                         {
 869                                 command_run_linef(cmd_ctx, "jtag_khz %d", (int)svf_para.frequency / 1000);
 870                                 LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
 871                         }
 872                 }
 873                 break;
 874         case HDR:
 875                 xxr_para_tmp = &svf_para.hdr_para;
 876                 goto XXR_common;
 877         case HIR:
 878                 xxr_para_tmp = &svf_para.hir_para;
 879                 goto XXR_common;
 880         case TDR:
 881                 xxr_para_tmp = &svf_para.tdr_para;
 882                 goto XXR_common;
 883         case TIR:
 884                 xxr_para_tmp = &svf_para.tir_para;
 885                 goto XXR_common;
 886         case SDR:
 887                 xxr_para_tmp = &svf_para.sdr_para;
 888                 goto XXR_common;
 889         case SIR:
 890                 xxr_para_tmp = &svf_para.sir_para;
 891                 goto XXR_common;
 892                 XXR_common:
 893                 // XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
 894                 if ((num_of_argu > 10) || (num_of_argu % 2))
 895                 {
 896                         LOG_ERROR("invalid parameter of %s", argus[0]);
 897                         return ERROR_FAIL;
 898                 }
 899                 i_tmp = xxr_para_tmp->len;
 900                 xxr_para_tmp->len = atoi(argus[1]);
 901                 LOG_DEBUG("\tlength = %d", xxr_para_tmp->len);
 902                 xxr_para_tmp->data_mask = 0;
 903                 for (i = 2; i < num_of_argu; i += 2)
 904                 {
 905                         if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') || (argus[i + 1][strlen(argus[i + 1]) - 1] != ')'))
 906                         {
 907                                 LOG_ERROR("data section error");
 908                                 return ERROR_FAIL;
 909                         }
 910                         argus[i + 1][strlen(argus[i + 1]) - 1] = '\0';
 911                         // TDI, TDO, MASK, SMASK
 912                         if (!strcmp(argus[i], "TDI"))
 913                         {
 914                                 // TDI
 915                                 pbuffer_tmp = &xxr_para_tmp->tdi;
 916                                 xxr_para_tmp->data_mask |= XXR_TDI;
 917                         }
 918                         else if (!strcmp(argus[i], "TDO"))
 919                         {
 920                                 // TDO
 921                                 pbuffer_tmp = &xxr_para_tmp->tdo;
 922                                 xxr_para_tmp->data_mask |= XXR_TDO;
 923                         }
 924                         else if (!strcmp(argus[i], "MASK"))
 925                         {
 926                                 // MASK
 927                                 pbuffer_tmp = &xxr_para_tmp->mask;
 928                                 xxr_para_tmp->data_mask |= XXR_MASK;
 929                         }
 930                         else if (!strcmp(argus[i], "SMASK"))
 931                         {
 932                                 // SMASK
 933                                 pbuffer_tmp = &xxr_para_tmp->smask;
 934                                 xxr_para_tmp->data_mask |= XXR_SMASK;
 935                         }
 936                         else
 937                         {
 938                                 LOG_ERROR("unknow parameter: %s", argus[i]);
 939                                 return ERROR_FAIL;
 940                         }
 941                         if (ERROR_OK != svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp, xxr_para_tmp->len))
 942                         {
 943                                 LOG_ERROR("fail to parse hex value");
 944                                 return ERROR_FAIL;
 945                         }
 946                         LOG_DEBUG("\t%s = 0x%X", argus[i], (**(int**)pbuffer_tmp) & svf_get_mask_u32(xxr_para_tmp->len));
 947                 }
 948                 // If a command changes the length of the last scan of the same type and the MASK parameter is absent,
 949                 // the mask pattern used is all cares
 950                 if (!(xxr_para_tmp->data_mask & XXR_MASK) && (i_tmp != xxr_para_tmp->len))
 951                 {
 952                         // MASK not defined and length changed
 953                         if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
 954                         {
 955                                 LOG_ERROR("fail to adjust length of array");
 956                                 return ERROR_FAIL;
 957                         }
 958                         buf_set_ones(xxr_para_tmp->mask, xxr_para_tmp->len);
 959                 }
 960                 // If TDO is absent, no comparison is needed, set the mask to 0
 961                 if (!(xxr_para_tmp->data_mask & XXR_TDO))
 962                 {
 963                         if (NULL == xxr_para_tmp->tdo)
 964                         {
 965                                 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp, xxr_para_tmp->len))
 966                                 {
 967                                         LOG_ERROR("fail to adjust length of array");
 968                                         return ERROR_FAIL;
 969                                 }
 970                         }
 971                         if (NULL == xxr_para_tmp->mask)
 972                         {
 973                                 if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
 974                                 {
 975                                         LOG_ERROR("fail to adjust length of array");
 976                                         return ERROR_FAIL;
 977                                 }
 978                         }
 979                         memset(xxr_para_tmp->mask, 0, (xxr_para_tmp->len + 7) >> 3);
 980                 }
 981                 // do scan if necessary
 982                 if (SDR == command)
 983                 {
 984                         // check buffer size first, reallocate if necessary
 985                         i = svf_para.hdr_para.len + svf_para.sdr_para.len + svf_para.tdr_para.len;
 986                         if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3))
 987                         {
 988 #if 1
 989                                 // simply print error message
 990                                 LOG_ERROR("buffer is not enough, report to author");
 991                                 return ERROR_FAIL;
 992 #else
 993                                 uint8_t *buffer_tmp;
 994
 995                                 // reallocate buffer
 996                                 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
 997                                 if (NULL == buffer_tmp)
 998                                 {
 999                                         LOG_ERROR("not enough memory");
1000                                         return ERROR_FAIL;
1001                                 }
1002                                 memcpy(buffer_tmp, svf_tdi_buffer, svf_buffer_index);
1003                                 // svf_tdi_buffer isn't NULL here
1004                                 free(svf_tdi_buffer);
1005                                 svf_tdi_buffer = buffer_tmp;
1006
1007                                 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1008                                 if (NULL == buffer_tmp)
1009                                 {
1010                                         LOG_ERROR("not enough memory");
1011                                         return ERROR_FAIL;
1012                                 }
1013                                 memcpy(buffer_tmp, svf_tdo_buffer, svf_buffer_index);
1014                                 // svf_tdo_buffer isn't NULL here
1015                                 free(svf_tdo_buffer);
1016                                 svf_tdo_buffer = buffer_tmp;
1017
1018                                 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1019                                 if (NULL == buffer_tmp)
1020                                 {
1021                                         LOG_ERROR("not enough memory");
1022                                         return ERROR_FAIL;
1023                                 }
1024                                 memcpy(buffer_tmp, svf_mask_buffer, svf_buffer_index);
1025                                 // svf_mask_buffer isn't NULL here
1026                                 free(svf_mask_buffer);
1027                                 svf_mask_buffer = buffer_tmp;
1028
1029                                 buffer_tmp = NULL;
1030                                 svf_buffer_size = svf_buffer_index + ((i + 7) >> 3);
1031 #endif
1032                         }
1033
1034                         // assemble dr data
1035                         i = 0;
1036                         buf_set_buf(svf_para.hdr_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1037                         i += svf_para.hdr_para.len;
1038                         buf_set_buf(svf_para.sdr_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1039                         i += svf_para.sdr_para.len;
1040                         buf_set_buf(svf_para.tdr_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1041                         i += svf_para.tdr_para.len;
1042
1043                         // add check data
1044                         if (svf_para.sdr_para.data_mask & XXR_TDO)
1045                         {
1046                                 // assemble dr mask data
1047                                 i = 0;
1048                                 buf_set_buf(svf_para.hdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1049                                 i += svf_para.hdr_para.len;
1050                                 buf_set_buf(svf_para.sdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1051                                 i += svf_para.sdr_para.len;
1052                                 buf_set_buf(svf_para.tdr_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1053                                 i += svf_para.tdr_para.len;
1054                                 // assemble dr check data
1055                                 i = 0;
1056                                 buf_set_buf(svf_para.hdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.hdr_para.len);
1057                                 i += svf_para.hdr_para.len;
1058                                 buf_set_buf(svf_para.sdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.sdr_para.len);
1059                                 i += svf_para.sdr_para.len;
1060                                 buf_set_buf(svf_para.tdr_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.tdr_para.len);
1061                                 i += svf_para.tdr_para.len;
1062
1063                                 svf_add_check_para(1, svf_buffer_index, i);
1064                         }
1065                         else
1066                         {
1067                                 svf_add_check_para(0, svf_buffer_index, i);
1068                         }
1069                         field.tap = tap;
1070                         field.num_bits = i;
1071                         field.out_value = &svf_tdi_buffer[svf_buffer_index];
1072                         field.in_value = &svf_tdi_buffer[svf_buffer_index];
1073                         jtag_add_plain_dr_scan(1, &field, svf_para.dr_end_state);
1074
1075                         svf_buffer_index += (i + 7) >> 3;
1076                 }
1077                 else if (SIR == command)
1078                 {
1079                         // check buffer size first, reallocate if necessary
1080                         i = svf_para.hir_para.len + svf_para.sir_para.len + svf_para.tir_para.len;
1081                         if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3))
1082                         {
1083 #if 1
1084                                 // simply print error message
1085                                 LOG_ERROR("buffer is not enough, report to author");
1086                                 return ERROR_FAIL;
1087 #else
1088                                 uint8_t *buffer_tmp;
1089
1090                                 // reallocate buffer
1091                                 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1092                                 if (NULL == buffer_tmp)
1093                                 {
1094                                         LOG_ERROR("not enough memory");
1095                                         return ERROR_FAIL;
1096                                 }
1097                                 memcpy(buffer_tmp, svf_tdi_buffer, svf_buffer_index);
1098                                 // svf_tdi_buffer isn't NULL here
1099                                 free(svf_tdi_buffer);
1100                                 svf_tdi_buffer = buffer_tmp;
1101
1102                                 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1103                                 if (NULL == buffer_tmp)
1104                                 {
1105                                         LOG_ERROR("not enough memory");
1106                                         return ERROR_FAIL;
1107                                 }
1108                                 memcpy(buffer_tmp, svf_tdo_buffer, svf_buffer_index);
1109                                 // svf_tdo_buffer isn't NULL here
1110                                 free(svf_tdo_buffer);
1111                                 svf_tdo_buffer = buffer_tmp;
1112
1113                                 buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
1114                                 if (NULL == buffer_tmp)
1115                                 {
1116                                         LOG_ERROR("not enough memory");
1117                                         return ERROR_FAIL;
1118                                 }
1119                                 memcpy(buffer_tmp, svf_mask_buffer, svf_buffer_index);
1120                                 // svf_mask_buffer isn't NULL here
1121                                 free(svf_mask_buffer);
1122                                 svf_mask_buffer = buffer_tmp;
1123
1124                                 buffer_tmp = NULL;
1125                                 svf_buffer_size = svf_buffer_index + ((i + 7) >> 3);
1126 #endif
1127                         }
1128
1129                         // assemble ir data
1130                         i = 0;
1131                         buf_set_buf(svf_para.hir_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1132                         i += svf_para.hir_para.len;
1133                         buf_set_buf(svf_para.sir_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1134                         i += svf_para.sir_para.len;
1135                         buf_set_buf(svf_para.tir_para.tdi, 0, &svf_tdi_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1136                         i += svf_para.tir_para.len;
1137
1138                         // add check data
1139                         if (svf_para.sir_para.data_mask & XXR_TDO)
1140                         {
1141                                 // assemble dr mask data
1142                                 i = 0;
1143                                 buf_set_buf(svf_para.hir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1144                                 i += svf_para.hir_para.len;
1145                                 buf_set_buf(svf_para.sir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1146                                 i += svf_para.sir_para.len;
1147                                 buf_set_buf(svf_para.tir_para.mask, 0, &svf_mask_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1148                                 i += svf_para.tir_para.len;
1149                                 // assemble dr check data
1150                                 i = 0;
1151                                 buf_set_buf(svf_para.hir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.hir_para.len);
1152                                 i += svf_para.hir_para.len;
1153                                 buf_set_buf(svf_para.sir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.sir_para.len);
1154                                 i += svf_para.sir_para.len;
1155                                 buf_set_buf(svf_para.tir_para.tdo, 0, &svf_tdo_buffer[svf_buffer_index], i, svf_para.tir_para.len);
1156                                 i += svf_para.tir_para.len;
1157
1158                                 svf_add_check_para(1, svf_buffer_index, i);
1159                         }
1160                         else
1161                         {
1162                                 svf_add_check_para(0, svf_buffer_index, i);
1163                         }
1164                         field.tap = tap;
1165                         field.num_bits = i;
1166                         field.out_value = &svf_tdi_buffer[svf_buffer_index];
1167                         field.in_value = &svf_tdi_buffer[svf_buffer_index];
1168                         jtag_add_plain_ir_scan(1, &field, svf_para.ir_end_state);
1169
1170                         svf_buffer_index += (i + 7) >> 3;
1171                 }
1172                 break;
1173         case PIO:
1174         case PIOMAP:
1175                 LOG_ERROR("PIO and PIOMAP are not supported");
1176                 return ERROR_FAIL;
1177                 break;
1178         case RUNTEST:
1179                 // RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time SEC]] [ENDSTATE end_state]
1180                 // RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE end_state]
1181                 if ((num_of_argu < 3) && (num_of_argu > 11))
1182                 {
1183                         LOG_ERROR("invalid parameter of %s", argus[0]);
1184                         return ERROR_FAIL;
1185                 }
1186                 // init
1187                 run_count = 0;
1188                 min_time = 0;
1189                 max_time = 0;
1190                 i = 1;
1191                 // run_state
1192                 i_tmp = svf_find_string_in_array(argus[i], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1193                 if (svf_tap_state_is_valid(i_tmp))
1194                 {
1195                         if (svf_tap_state_is_stable(i_tmp))
1196                         {
1197                                 svf_para.runtest_run_state = i_tmp;
1198
1199                                 // When a run_state is specified, the new  run_state becomes the default end_state
1200                                 svf_para.runtest_end_state = i_tmp;
1201                                 LOG_DEBUG("\trun_state = %s", svf_tap_state_name[svf_para.runtest_run_state]);
1202                                 i++;
1203                         }
1204                         else
1205                         {
1206                                 LOG_ERROR("%s is not valid state", svf_tap_state_name[i_tmp]);
1207                                 return ERROR_FAIL;
1208                         }
1209                 }
1210                 // run_count run_clk
1211                 if (((i + 2) <= num_of_argu) && strcmp(argus[i + 1], "SEC"))
1212                 {
1213                         if (!strcmp(argus[i + 1], "TCK"))
1214                         {
1215                                 // clock source is TCK
1216                                 run_count = atoi(argus[i]);
1217                                 LOG_DEBUG("\trun_count@TCK = %d", run_count);
1218                         }
1219                         else
1220                         {
1221                                 LOG_ERROR("%s not supported for clock", argus[i + 1]);
1222                                 return ERROR_FAIL;
1223                         }
1224                         i += 2;
1225                 }
1226                 // min_time SEC
1227                 if (((i + 2) <= num_of_argu) && !strcmp(argus[i + 1], "SEC"))
1228                 {
1229                         min_time = atof(argus[i]);
1230                         LOG_DEBUG("\tmin_time = %fs", min_time);
1231                         i += 2;
1232                 }
1233                 // MAXIMUM max_time SEC
1234                 if (((i + 3) <= num_of_argu) && !strcmp(argus[i], "MAXIMUM") && !strcmp(argus[i + 2], "SEC"))
1235                 {
1236                         max_time = atof(argus[i + 1]);
1237                         LOG_DEBUG("\tmax_time = %fs", max_time);
1238                         i += 3;
1239                 }
1240                 // ENDSTATE end_state
1241                 if (((i + 2) <= num_of_argu) && !strcmp(argus[i], "ENDSTATE"))
1242                 {
1243                         i_tmp = svf_find_string_in_array(argus[i + 1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1244                         if (svf_tap_state_is_stable(i_tmp))
1245                         {
1246                                 svf_para.runtest_end_state = i_tmp;
1247                                 LOG_DEBUG("\tend_state = %s", svf_tap_state_name[svf_para.runtest_end_state]);
1248                         }
1249                         else
1250                         {
1251                                 LOG_ERROR("%s is not valid state", svf_tap_state_name[i_tmp]);
1252                                 return ERROR_FAIL;
1253                         }
1254                         i += 2;
1255                 }
1256                 // calculate run_count
1257                 if ((0 == run_count) && (min_time > 0))
1258                 {
1259                         run_count = min_time * svf_para.frequency;
1260                 }
1261                 // all parameter should be parsed
1262                 if (i == num_of_argu)
1263                 {
1264                         if (run_count > 0)
1265                         {
1266                                 // run_state and end_state is checked to be stable state
1267                                 // TODO: do runtest
1268 #if 1
1269                                 // enter into run_state if necessary
1270                                 if (cmd_queue_cur_state != svf_para.runtest_run_state)
1271                                 {
1272                                         svf_add_statemove(svf_para.runtest_run_state);
1273                                 }
1274
1275                                 // call jtag_add_clocks
1276                                 jtag_add_clocks(run_count);
1277
1278                                 // move to end_state if necessary
1279                                 if (svf_para.runtest_end_state != svf_para.runtest_run_state)
1280                                 {
1281                                         svf_add_statemove(svf_para.runtest_end_state);
1282                                 }
1283 #else
1284                                 if (svf_para.runtest_run_state != TAP_IDLE)
1285                                 {
1286                                         // RUNTEST can only executed in TAP_IDLE
1287                                         LOG_ERROR("cannot runtest in %s state", svf_tap_state_name[svf_para.runtest_run_state]);
1288                                         return ERROR_FAIL;
1289                                 }
1290
1291                                 jtag_add_runtest(run_count, svf_para.runtest_end_state);
1292 #endif
1293                         }
1294                 }
1295                 else
1296                 {
1297                         LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed", i, num_of_argu);
1298                         return ERROR_FAIL;
1299                 }
1300                 break;
1301         case STATE:
1302                 // STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state
1303                 if (num_of_argu < 2)
1304                 {
1305                         LOG_ERROR("invalid parameter of %s", argus[0]);
1306                         return ERROR_FAIL;
1307                 }
1308                 if (num_of_argu > 2)
1309                 {
1310                         // STATE pathstate1 ... stable_state
1311                         path = (tap_state_t *)malloc((num_of_argu - 1) * sizeof(tap_state_t));
1312                         if (NULL == path)
1313                         {
1314                                 LOG_ERROR("not enough memory");
1315                                 return ERROR_FAIL;
1316                         }
1317                         num_of_argu--;          // num of path
1318                         i_tmp = 1;                      // path is from patameter 1
1319                         for (i = 0; i < num_of_argu; i++)
1320                         {
1321                                 path[i] = svf_find_string_in_array(argus[i_tmp++], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1322                                 if (!svf_tap_state_is_valid(path[i]))
1323                                 {
1324                                         LOG_ERROR("%s is not valid state", svf_tap_state_name[path[i]]);
1325                                         free(path);
1326                                         return ERROR_FAIL;
1327                                 }
1328                                 if (TAP_RESET == path[i])
1329                                 {
1330                                         if (i > 0)
1331                                         {
1332                                                 jtag_add_pathmove(i, path);
1333                                         }
1334                                         jtag_add_tlr();
1335                                         num_of_argu -= i + 1;
1336                                         i = -1;
1337                                 }
1338                         }
1339                         if (num_of_argu > 0)
1340                         {
1341                                 // execute last path if necessary
1342                                 if (svf_tap_state_is_stable(path[num_of_argu - 1]))
1343                                 {
1344                                         // last state MUST be stable state
1345                                         // TODO: call path_move
1346                                         jtag_add_pathmove(num_of_argu, path);
1347                                         LOG_DEBUG("\tmove to %s by path_move", svf_tap_state_name[path[num_of_argu - 1]]);
1348                                 }
1349                                 else
1350                                 {
1351                                         LOG_ERROR("%s is not valid state", svf_tap_state_name[path[num_of_argu - 1]]);
1352                                         free(path);
1353                                         return ERROR_FAIL;
1354                                 }
1355                         }
1356                         // no need to keep this memory, in jtag_add_pathmove, path will be duplicated
1357                         if (NULL != path)
1358                         {
1359                                 free(path);
1360                                 path = NULL;
1361                         }
1362                 }
1363                 else
1364                 {
1365                         // STATE stable_state
1366                         state = svf_find_string_in_array(argus[1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
1367                         if (svf_tap_state_is_stable(state))
1368                         {
1369                                 // TODO: move to state
1370                                 svf_add_statemove(state);
1371
1372                                 LOG_DEBUG("\tmove to %s by svf_add_statemove", svf_tap_state_name[state]);
1373                         }
1374                         else
1375                         {
1376                                 LOG_ERROR("%s is not valid state", svf_tap_state_name[state]);
1377                                 return ERROR_FAIL;
1378                         }
1379                 }
1380                 break;
1381         case TRST:
1382                 // TRST trst_mode
1383                 if (num_of_argu != 2)
1384                 {
1385                         LOG_ERROR("invalid parameter of %s", argus[0]);
1386                         return ERROR_FAIL;
1387                 }
1388                 if (svf_para.trst_mode != TRST_ABSENT)
1389                 {
1390                         if (ERROR_OK != svf_execute_tap())
1391                         {
1392                                 return ERROR_FAIL;
1393                         }
1394                         i_tmp = svf_find_string_in_array(argus[1], (char **)svf_trst_mode_name, dimof(svf_trst_mode_name));
1395                         switch (i_tmp)
1396                         {
1397                         case TRST_ON:
1398                                 jtag_add_reset(1, 0);
1399                                 break;
1400                         case TRST_Z:
1401                         case TRST_OFF:
1402                                 jtag_add_reset(0, 0);
1403                                 break;
1404                         case TRST_ABSENT:
1405                                 break;
1406                         default:
1407                                 LOG_ERROR("unknown TRST mode: %s", argus[1]);
1408                                 return ERROR_FAIL;
1409                         }
1410                         svf_para.trst_mode = i_tmp;
1411                         LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name[svf_para.trst_mode]);
1412                 }
1413                 else
1414                 {
1415                         LOG_ERROR("can not accpet TRST command if trst_mode is ABSENT");
1416                         return ERROR_FAIL;
1417                 }
1418                 break;
1419         default:
1420                 LOG_ERROR("invalid svf command: %s", argus[0]);
1421                 return ERROR_FAIL;
1422                 break;
1423         }
1424
1425         if (debug_level >= LOG_LVL_DEBUG)
1426         {
1427                 // for convenient debugging, execute tap if possible
1428                 if ((svf_buffer_index > 0) && \
1429                         (((command != STATE) && (command != RUNTEST)) || \
1430                         ((command == STATE) && (num_of_argu == 2))))
1431                 {
1432                         if (ERROR_OK != svf_execute_tap())
1433                         {
1434                                 return ERROR_FAIL;
1435                         }
1436
1437                         // output debug info
1438                         if ((SIR == command) || (SDR == command))
1439                         {
1440                                 int read_value;
1441                                 memcpy(&read_value, svf_tdi_buffer, sizeof(int));
1442                                 // in debug mode, data is from index 0
1443                                 int read_mask = svf_get_mask_u32(svf_check_tdo_para[0].bit_len);
1444                                 LOG_DEBUG("\tTDO read = 0x%X", read_value & read_mask);
1445                         }
1446                 }
1447         }
1448         else
1449         {
1450                 // for fast executing, execute tap if necessary
1451                 // half of the buffer is for the next command
1452                 if (((svf_buffer_index >= SVF_MAX_BUFFER_SIZE_TO_COMMIT) || (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE / 2)) && \
1453                         (((command != STATE) && (command != RUNTEST)) || \
1454                         ((command == STATE) && (num_of_argu == 2))))
1455                 {
1456                         return svf_execute_tap();
1457                 }
1458         }
1459
1460         return ERROR_OK;
1461 }