You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1403 lines
34 KiB

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