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.
 
 
 
 
 
 

2955 lines
76 KiB

  1. /***************************************************************************
  2. * Copyright (C) 2005 by Dominic Rath *
  3. * Dominic.Rath@gmx.de *
  4. * *
  5. * Copyright (C) 2007,2008 Øyvind Harboe *
  6. * oyvind.harboe@zylin.com *
  7. * *
  8. * This program is free software; you can redistribute it and/or modify *
  9. * it under the terms of the GNU General Public License as published by *
  10. * the Free Software Foundation; either version 2 of the License, or *
  11. * (at your option) any later version. *
  12. * *
  13. * This program is distributed in the hope that it will be useful, *
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of *
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
  16. * GNU General Public License for more details. *
  17. * *
  18. * You should have received a copy of the GNU General Public License *
  19. * along with this program; if not, write to the *
  20. * Free Software Foundation, Inc., *
  21. * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
  22. ***************************************************************************/
  23. #ifdef HAVE_CONFIG_H
  24. #include "config.h"
  25. #endif
  26. #include "replacements.h"
  27. #include "jtag.h"
  28. #include "command.h"
  29. #include "log.h"
  30. #include "stdlib.h"
  31. #include "string.h"
  32. #include <unistd.h>
  33. /* note that this is not marked as static as it must be available from outside jtag.c for those
  34. that implement the jtag_xxx() minidriver layer
  35. */
  36. int jtag_error=ERROR_OK;
  37. typedef struct cmd_queue_page_s
  38. {
  39. void *address;
  40. size_t used;
  41. struct cmd_queue_page_s *next;
  42. } cmd_queue_page_t;
  43. #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
  44. static cmd_queue_page_t *cmd_queue_pages = NULL;
  45. /* tap_move[i][j]: tap movement command to go from state i to state j
  46. * 0: Test-Logic-Reset
  47. * 1: Run-Test/Idle
  48. * 2: Shift-DR
  49. * 3: Pause-DR
  50. * 4: Shift-IR
  51. * 5: Pause-IR
  52. *
  53. * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
  54. */
  55. u8 tap_move[6][6] =
  56. {
  57. /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
  58. { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* RESET */
  59. { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* IDLE */
  60. { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* DRSHIFT */
  61. { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* DRPAUSE */
  62. { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* IRSHIFT */
  63. { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* IRPAUSE */
  64. };
  65. int tap_move_map[16] = {
  66. 0, -1, -1, 2, -1, 3, -1, -1,
  67. 1, -1, -1, 4, -1, 5, -1, -1
  68. };
  69. tap_transition_t tap_transitions[16] =
  70. {
  71. {TAP_RESET, TAP_IDLE}, /* RESET */
  72. {TAP_IRSELECT, TAP_DRCAPTURE}, /* DRSELECT */
  73. {TAP_DREXIT1, TAP_DRSHIFT}, /* DRCAPTURE */
  74. {TAP_DREXIT1, TAP_DRSHIFT}, /* DRSHIFT */
  75. {TAP_DRUPDATE, TAP_DRPAUSE}, /* DREXIT1 */
  76. {TAP_DREXIT2, TAP_DRPAUSE}, /* DRPAUSE */
  77. {TAP_DRUPDATE, TAP_DRSHIFT}, /* DREXIT2 */
  78. {TAP_DRSELECT, TAP_IDLE}, /* DRUPDATE */
  79. {TAP_DRSELECT, TAP_IDLE}, /* IDLE */
  80. {TAP_RESET, TAP_IRCAPTURE}, /* IRSELECT */
  81. {TAP_IREXIT1, TAP_IRSHIFT}, /* IRCAPTURE */
  82. {TAP_IREXIT1, TAP_IRSHIFT}, /* IRSHIFT */
  83. {TAP_IRUPDATE, TAP_IRPAUSE}, /* IREXIT1 */
  84. {TAP_IREXIT2, TAP_IRPAUSE}, /* IRPAUSE */
  85. {TAP_IRUPDATE, TAP_IRSHIFT}, /* IREXIT2 */
  86. {TAP_DRSELECT, TAP_IDLE} /* IRUPDATE */
  87. };
  88. char* jtag_event_strings[] =
  89. {
  90. "JTAG controller reset (RESET or TRST)"
  91. };
  92. const Jim_Nvp nvp_jtag_tap_event[] = {
  93. { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
  94. { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
  95. { .name = NULL, .value = -1 }
  96. };
  97. /* kludge!!!! these are just global variables that the
  98. * interface use internally. They really belong
  99. * inside the drivers, but we don't want to break
  100. * linking the drivers!!!!
  101. */
  102. enum tap_state end_state = TAP_RESET;
  103. enum tap_state cur_state = TAP_RESET;
  104. int jtag_trst = 0;
  105. int jtag_srst = 0;
  106. jtag_command_t *jtag_command_queue = NULL;
  107. jtag_command_t **last_comand_pointer = &jtag_command_queue;
  108. static jtag_tap_t *jtag_all_taps = NULL;
  109. enum reset_types jtag_reset_config = RESET_NONE;
  110. enum tap_state cmd_queue_end_state = TAP_RESET;
  111. enum tap_state cmd_queue_cur_state = TAP_RESET;
  112. int jtag_verify_capture_ir = 1;
  113. /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
  114. int jtag_nsrst_delay = 0; /* default to no nSRST delay */
  115. int jtag_ntrst_delay = 0; /* default to no nTRST delay */
  116. /* maximum number of JTAG devices expected in the chain
  117. */
  118. #define JTAG_MAX_CHAIN_SIZE 20
  119. /* callbacks to inform high-level handlers about JTAG state changes */
  120. jtag_event_callback_t *jtag_event_callbacks;
  121. /* speed in kHz*/
  122. static int speed_khz = 0;
  123. /* flag if the kHz speed was defined */
  124. static int hasKHz = 0;
  125. /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
  126. */
  127. #if BUILD_ECOSBOARD == 1
  128. extern jtag_interface_t zy1000_interface;
  129. #endif
  130. #if BUILD_PARPORT == 1
  131. extern jtag_interface_t parport_interface;
  132. #endif
  133. #if BUILD_DUMMY == 1
  134. extern jtag_interface_t dummy_interface;
  135. #endif
  136. #if BUILD_FT2232_FTD2XX == 1
  137. extern jtag_interface_t ft2232_interface;
  138. #endif
  139. #if BUILD_FT2232_LIBFTDI == 1
  140. extern jtag_interface_t ft2232_interface;
  141. #endif
  142. #if BUILD_AMTJTAGACCEL == 1
  143. extern jtag_interface_t amt_jtagaccel_interface;
  144. #endif
  145. #if BUILD_EP93XX == 1
  146. extern jtag_interface_t ep93xx_interface;
  147. #endif
  148. #if BUILD_AT91RM9200 == 1
  149. extern jtag_interface_t at91rm9200_interface;
  150. #endif
  151. #if BUILD_GW16012 == 1
  152. extern jtag_interface_t gw16012_interface;
  153. #endif
  154. #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
  155. extern jtag_interface_t presto_interface;
  156. #endif
  157. #if BUILD_USBPROG == 1
  158. extern jtag_interface_t usbprog_interface;
  159. #endif
  160. #if BUILD_JLINK == 1
  161. extern jtag_interface_t jlink_interface;
  162. #endif
  163. #if BUILD_VSLLINK == 1
  164. extern jtag_interface_t vsllink_interface;
  165. #endif
  166. #if BUILD_RLINK == 1
  167. extern jtag_interface_t rlink_interface;
  168. #endif
  169. jtag_interface_t *jtag_interfaces[] = {
  170. #if BUILD_ECOSBOARD == 1
  171. &zy1000_interface,
  172. #endif
  173. #if BUILD_PARPORT == 1
  174. &parport_interface,
  175. #endif
  176. #if BUILD_DUMMY == 1
  177. &dummy_interface,
  178. #endif
  179. #if BUILD_FT2232_FTD2XX == 1
  180. &ft2232_interface,
  181. #endif
  182. #if BUILD_FT2232_LIBFTDI == 1
  183. &ft2232_interface,
  184. #endif
  185. #if BUILD_AMTJTAGACCEL == 1
  186. &amt_jtagaccel_interface,
  187. #endif
  188. #if BUILD_EP93XX == 1
  189. &ep93xx_interface,
  190. #endif
  191. #if BUILD_AT91RM9200 == 1
  192. &at91rm9200_interface,
  193. #endif
  194. #if BUILD_GW16012 == 1
  195. &gw16012_interface,
  196. #endif
  197. #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
  198. &presto_interface,
  199. #endif
  200. #if BUILD_USBPROG == 1
  201. &usbprog_interface,
  202. #endif
  203. #if BUILD_JLINK == 1
  204. &jlink_interface,
  205. #endif
  206. #if BUILD_VSLLINK == 1
  207. &vsllink_interface,
  208. #endif
  209. #if BUILD_RLINK == 1
  210. &rlink_interface,
  211. #endif
  212. NULL,
  213. };
  214. jtag_interface_t *jtag = NULL;
  215. /* configuration */
  216. jtag_interface_t *jtag_interface = NULL;
  217. int jtag_speed = 0;
  218. /* forward declarations */
  219. void jtag_add_pathmove(int num_states, enum tap_state *path);
  220. void jtag_add_runtest(int num_cycles, enum tap_state endstate);
  221. void jtag_add_end_state(enum tap_state endstate);
  222. void jtag_add_sleep(u32 us);
  223. int jtag_execute_queue(void);
  224. /* jtag commands */
  225. int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  226. int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  227. int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  228. int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  229. int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  230. int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  231. int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  232. int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  233. int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  234. int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  235. int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  236. int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  237. int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
  238. int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  239. jtag_tap_t *jtag_AllTaps(void)
  240. {
  241. return jtag_all_taps;
  242. };
  243. int jtag_NumTotalTaps(void)
  244. {
  245. jtag_tap_t *t;
  246. int n;
  247. n = 0;
  248. t = jtag_AllTaps();
  249. while(t){
  250. n++;
  251. t = t->next_tap;
  252. }
  253. return n;
  254. }
  255. int jtag_NumEnabledTaps(void)
  256. {
  257. jtag_tap_t *t;
  258. int n;
  259. n = 0;
  260. t = jtag_AllTaps();
  261. while(t){
  262. if( t->enabled ){
  263. n++;
  264. }
  265. t = t->next_tap;
  266. }
  267. return n;
  268. }
  269. jtag_tap_t *jtag_TapByString( const char *s )
  270. {
  271. jtag_tap_t *t;
  272. char *cp;
  273. t = jtag_AllTaps();
  274. // try name first
  275. while(t){
  276. if( 0 == strcmp( t->dotted_name, s ) ){
  277. break;
  278. } else {
  279. t = t->next_tap;
  280. }
  281. }
  282. // backup plan is by number
  283. if( t == NULL ){
  284. /* ok - is "s" a number? */
  285. int n;
  286. n = strtol( s, &cp, 0 );
  287. if( (s != cp) && (*cp == 0) ){
  288. /* Then it is... */
  289. t = jtag_TapByAbsPosition(n);
  290. }
  291. }
  292. return t;
  293. }
  294. jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
  295. {
  296. jtag_tap_t *t;
  297. const char *cp;
  298. cp = Jim_GetString( o, NULL );
  299. if(cp == NULL){
  300. cp = "(unknown)";
  301. t = NULL;
  302. } else {
  303. t = jtag_TapByString( cp );
  304. }
  305. if( t == NULL ){
  306. Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
  307. }
  308. return t;
  309. }
  310. /* returns a pointer to the n-th device in the scan chain */
  311. jtag_tap_t * jtag_TapByAbsPosition( int n )
  312. {
  313. int orig_n;
  314. jtag_tap_t *t;
  315. orig_n = n;
  316. t = jtag_AllTaps();
  317. while( t && (n > 0)) {
  318. n--;
  319. t = t->next_tap;
  320. }
  321. return t;
  322. }
  323. int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
  324. {
  325. jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
  326. if (callback == NULL)
  327. {
  328. return ERROR_INVALID_ARGUMENTS;
  329. }
  330. if (*callbacks_p)
  331. {
  332. while ((*callbacks_p)->next)
  333. callbacks_p = &((*callbacks_p)->next);
  334. callbacks_p = &((*callbacks_p)->next);
  335. }
  336. (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
  337. (*callbacks_p)->callback = callback;
  338. (*callbacks_p)->priv = priv;
  339. (*callbacks_p)->next = NULL;
  340. return ERROR_OK;
  341. }
  342. int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
  343. {
  344. jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
  345. if (callback == NULL)
  346. {
  347. return ERROR_INVALID_ARGUMENTS;
  348. }
  349. while (*callbacks_p)
  350. {
  351. jtag_event_callback_t **next = &((*callbacks_p)->next);
  352. if ((*callbacks_p)->callback == callback)
  353. {
  354. free(*callbacks_p);
  355. *callbacks_p = *next;
  356. }
  357. callbacks_p = next;
  358. }
  359. return ERROR_OK;
  360. }
  361. int jtag_call_event_callbacks(enum jtag_event event)
  362. {
  363. jtag_event_callback_t *callback = jtag_event_callbacks;
  364. LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
  365. while (callback)
  366. {
  367. callback->callback(event, callback->priv);
  368. callback = callback->next;
  369. }
  370. return ERROR_OK;
  371. }
  372. /* returns a pointer to the pointer of the last command in queue
  373. * this may be a pointer to the root pointer (jtag_command_queue)
  374. * or to the next member of the last but one command
  375. */
  376. jtag_command_t** jtag_get_last_command_p(void)
  377. {
  378. /* jtag_command_t *cmd = jtag_command_queue;
  379. if (cmd)
  380. while (cmd->next)
  381. cmd = cmd->next;
  382. else
  383. return &jtag_command_queue;
  384. return &cmd->next;*/
  385. return last_comand_pointer;
  386. }
  387. void* cmd_queue_alloc(size_t size)
  388. {
  389. cmd_queue_page_t **p_page = &cmd_queue_pages;
  390. int offset;
  391. u8 *t;
  392. /*
  393. * WARNING:
  394. * We align/round the *SIZE* per below
  395. * so that all pointers returned by
  396. * this function are reasonably well
  397. * aligned.
  398. *
  399. * If we did not, then an "odd-length" request would cause the
  400. * *next* allocation to be at an *odd* address, and because
  401. * this function has the same type of api as malloc() - we
  402. * must also return pointers that have the same type of
  403. * alignment.
  404. *
  405. * What I do not/have is a reasonable portable means
  406. * to align by...
  407. *
  408. * The solution here, is based on these suggestions.
  409. * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
  410. *
  411. */
  412. union worse_case_align {
  413. int i;
  414. long l;
  415. float f;
  416. void *v;
  417. };
  418. #define ALIGN_SIZE (sizeof(union worse_case_align))
  419. /* The alignment process. */
  420. size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
  421. /* Done... */
  422. if (*p_page)
  423. {
  424. while ((*p_page)->next)
  425. p_page = &((*p_page)->next);
  426. if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
  427. p_page = &((*p_page)->next);
  428. }
  429. if (!*p_page)
  430. {
  431. *p_page = malloc(sizeof(cmd_queue_page_t));
  432. (*p_page)->used = 0;
  433. (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
  434. (*p_page)->next = NULL;
  435. }
  436. offset = (*p_page)->used;
  437. (*p_page)->used += size;
  438. t=(u8 *)((*p_page)->address);
  439. return t + offset;
  440. }
  441. void cmd_queue_free(void)
  442. {
  443. cmd_queue_page_t *page = cmd_queue_pages;
  444. while (page)
  445. {
  446. cmd_queue_page_t *last = page;
  447. free(page->address);
  448. page = page->next;
  449. free(last);
  450. }
  451. cmd_queue_pages = NULL;
  452. }
  453. static void jtag_prelude1(void)
  454. {
  455. if (jtag_trst == 1)
  456. {
  457. LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
  458. jtag_error=ERROR_JTAG_TRST_ASSERTED;
  459. return;
  460. }
  461. if (cmd_queue_end_state == TAP_RESET)
  462. jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
  463. }
  464. static void jtag_prelude(enum tap_state state)
  465. {
  466. jtag_prelude1();
  467. if (state != -1)
  468. jtag_add_end_state(state);
  469. cmd_queue_cur_state = cmd_queue_end_state;
  470. }
  471. void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
  472. {
  473. int retval;
  474. jtag_prelude(state);
  475. retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
  476. if (retval!=ERROR_OK)
  477. jtag_error=retval;
  478. }
  479. int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
  480. {
  481. jtag_command_t **last_cmd;
  482. jtag_tap_t *tap;
  483. int j;
  484. int x;
  485. int nth_tap;
  486. int scan_size = 0;
  487. last_cmd = jtag_get_last_command_p();
  488. /* allocate memory for a new list member */
  489. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  490. (*last_cmd)->next = NULL;
  491. last_comand_pointer = &((*last_cmd)->next);
  492. (*last_cmd)->type = JTAG_SCAN;
  493. /* allocate memory for ir scan command */
  494. (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
  495. (*last_cmd)->cmd.scan->ir_scan = 1;
  496. x = jtag_NumEnabledTaps();
  497. (*last_cmd)->cmd.scan->num_fields = x; /* one field per device */
  498. (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x * sizeof(scan_field_t));
  499. (*last_cmd)->cmd.scan->end_state = state;
  500. nth_tap = -1;
  501. tap = NULL;
  502. for(;;){
  503. int found = 0;
  504. // do this here so it is not forgotten
  505. tap = jtag_NextEnabledTap(tap);
  506. if( tap == NULL ){
  507. break;
  508. }
  509. nth_tap++;
  510. scan_size = tap->ir_length;
  511. (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
  512. (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
  513. (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
  514. (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL; /* disable verification by default */
  515. /* search the list */
  516. for (j = 0; j < num_fields; j++)
  517. {
  518. if (tap == fields[j].tap)
  519. {
  520. found = 1;
  521. (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
  522. (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
  523. if (jtag_verify_capture_ir)
  524. {
  525. if (fields[j].in_handler==NULL)
  526. {
  527. jtag_set_check_value((*last_cmd)->cmd.scan->fields+nth_tap, tap->expected, tap->expected_mask, NULL);
  528. } else
  529. {
  530. (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = fields[j].in_handler;
  531. (*last_cmd)->cmd.scan->fields[nth_tap].in_handler_priv = fields[j].in_handler_priv;
  532. (*last_cmd)->cmd.scan->fields[nth_tap].in_check_value = tap->expected;
  533. (*last_cmd)->cmd.scan->fields[nth_tap].in_check_mask = tap->expected_mask;
  534. }
  535. }
  536. tap->bypass = 0;
  537. break;
  538. }
  539. }
  540. if (!found)
  541. {
  542. /* if a tap isn't listed, set it to BYPASS */
  543. (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
  544. (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = NULL;
  545. tap->bypass = 1;
  546. }
  547. /* update device information */
  548. buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
  549. }
  550. return ERROR_OK;
  551. }
  552. void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
  553. {
  554. int retval;
  555. jtag_prelude(state);
  556. retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
  557. if (retval!=ERROR_OK)
  558. jtag_error=retval;
  559. }
  560. int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
  561. {
  562. int i;
  563. jtag_command_t **last_cmd;
  564. last_cmd = jtag_get_last_command_p();
  565. /* allocate memory for a new list member */
  566. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  567. (*last_cmd)->next = NULL;
  568. last_comand_pointer = &((*last_cmd)->next);
  569. (*last_cmd)->type = JTAG_SCAN;
  570. /* allocate memory for ir scan command */
  571. (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
  572. (*last_cmd)->cmd.scan->ir_scan = 1;
  573. (*last_cmd)->cmd.scan->num_fields = num_fields;
  574. (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
  575. (*last_cmd)->cmd.scan->end_state = state;
  576. for( i = 0 ; i < num_fields ; i++ ){
  577. int num_bits = fields[i].num_bits;
  578. int num_bytes = CEIL(fields[i].num_bits, 8);
  579. (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
  580. (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
  581. (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
  582. (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
  583. (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
  584. (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
  585. (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
  586. (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
  587. (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
  588. }
  589. return ERROR_OK;
  590. }
  591. void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
  592. {
  593. int retval;
  594. jtag_prelude(state);
  595. retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
  596. if (retval!=ERROR_OK)
  597. jtag_error=retval;
  598. }
  599. int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
  600. {
  601. int j;
  602. int nth_tap;
  603. int bypass_devices = 0;
  604. int field_count = 0;
  605. int scan_size;
  606. jtag_command_t **last_cmd = jtag_get_last_command_p();
  607. jtag_tap_t *tap;
  608. /* count devices in bypass */
  609. tap = NULL;
  610. bypass_devices = 0;
  611. for(;;){
  612. tap = jtag_NextEnabledTap(tap);
  613. if( tap == NULL ){
  614. break;
  615. }
  616. if( tap->bypass ){
  617. bypass_devices++;
  618. }
  619. }
  620. /* allocate memory for a new list member */
  621. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  622. last_comand_pointer = &((*last_cmd)->next);
  623. (*last_cmd)->next = NULL;
  624. (*last_cmd)->type = JTAG_SCAN;
  625. /* allocate memory for dr scan command */
  626. (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
  627. (*last_cmd)->cmd.scan->ir_scan = 0;
  628. (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
  629. (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
  630. (*last_cmd)->cmd.scan->end_state = state;
  631. tap = NULL;
  632. nth_tap = -1;
  633. for(;;){
  634. nth_tap++;
  635. tap = jtag_NextEnabledTap(tap);
  636. if( tap == NULL ){
  637. break;
  638. }
  639. int found = 0;
  640. (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
  641. for (j = 0; j < num_fields; j++)
  642. {
  643. if (tap == fields[j].tap)
  644. {
  645. found = 1;
  646. scan_size = fields[j].num_bits;
  647. (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
  648. (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
  649. (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
  650. (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
  651. (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
  652. (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
  653. (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
  654. (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
  655. }
  656. }
  657. if (!found)
  658. {
  659. #ifdef _DEBUG_JTAG_IO_
  660. /* if a device isn't listed, the BYPASS register should be selected */
  661. if (! tap->bypass)
  662. {
  663. LOG_ERROR("BUG: no scan data for a device not in BYPASS");
  664. exit(-1);
  665. }
  666. #endif
  667. /* program the scan field to 1 bit length, and ignore it's value */
  668. (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
  669. (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
  670. (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
  671. (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
  672. (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
  673. (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
  674. (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
  675. (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
  676. }
  677. else
  678. {
  679. #ifdef _DEBUG_JTAG_IO_
  680. /* if a device is listed, the BYPASS register must not be selected */
  681. if (tap->bypass)
  682. {
  683. LOG_ERROR("BUG: scan data for a device in BYPASS");
  684. exit(-1);
  685. }
  686. #endif
  687. }
  688. }
  689. return ERROR_OK;
  690. }
  691. void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
  692. int num_fields,
  693. const int *num_bits,
  694. const u32 *value,
  695. enum tap_state end_state)
  696. {
  697. int nth_tap;
  698. int field_count = 0;
  699. int scan_size;
  700. int bypass_devices = 0;
  701. jtag_command_t **last_cmd = jtag_get_last_command_p();
  702. jtag_tap_t *tap;
  703. /* count devices in bypass */
  704. tap = NULL;
  705. bypass_devices = 0;
  706. for(;;){
  707. tap = jtag_NextEnabledTap(tap);
  708. if( tap == NULL ){
  709. break;
  710. }
  711. if( tap->bypass ){
  712. bypass_devices++;
  713. }
  714. }
  715. /* allocate memory for a new list member */
  716. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  717. last_comand_pointer = &((*last_cmd)->next);
  718. (*last_cmd)->next = NULL;
  719. (*last_cmd)->type = JTAG_SCAN;
  720. /* allocate memory for dr scan command */
  721. (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
  722. (*last_cmd)->cmd.scan->ir_scan = 0;
  723. (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
  724. (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
  725. (*last_cmd)->cmd.scan->end_state = end_state;
  726. tap = NULL;
  727. nth_tap = -1;
  728. for(;;){
  729. tap = jtag_NextEnabledTap(tap);
  730. if( tap == NULL ){
  731. break;
  732. }
  733. nth_tap++;
  734. (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
  735. if (tap == target_tap)
  736. {
  737. int j;
  738. #ifdef _DEBUG_JTAG_IO_
  739. /* if a device is listed, the BYPASS register must not be selected */
  740. if (tap->bypass)
  741. {
  742. LOG_ERROR("BUG: scan data for a device in BYPASS");
  743. exit(-1);
  744. }
  745. #endif
  746. for (j = 0; j < num_fields; j++)
  747. {
  748. u8 out_value[4];
  749. scan_size = num_bits[j];
  750. buf_set_u32(out_value, 0, scan_size, value[j]);
  751. (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
  752. (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
  753. (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
  754. (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
  755. (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
  756. (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
  757. (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
  758. (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
  759. }
  760. } else
  761. {
  762. #ifdef _DEBUG_JTAG_IO_
  763. /* if a device isn't listed, the BYPASS register should be selected */
  764. if (! tap->bypass)
  765. {
  766. LOG_ERROR("BUG: no scan data for a device not in BYPASS");
  767. exit(-1);
  768. }
  769. #endif
  770. /* program the scan field to 1 bit length, and ignore it's value */
  771. (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
  772. (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
  773. (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
  774. (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
  775. (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
  776. (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
  777. (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
  778. (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
  779. }
  780. }
  781. }
  782. void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
  783. {
  784. int retval;
  785. jtag_prelude(state);
  786. retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
  787. if (retval!=ERROR_OK)
  788. jtag_error=retval;
  789. }
  790. int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
  791. {
  792. int i;
  793. jtag_command_t **last_cmd = jtag_get_last_command_p();
  794. /* allocate memory for a new list member */
  795. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  796. last_comand_pointer = &((*last_cmd)->next);
  797. (*last_cmd)->next = NULL;
  798. (*last_cmd)->type = JTAG_SCAN;
  799. /* allocate memory for scan command */
  800. (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
  801. (*last_cmd)->cmd.scan->ir_scan = 0;
  802. (*last_cmd)->cmd.scan->num_fields = num_fields;
  803. (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
  804. (*last_cmd)->cmd.scan->end_state = state;
  805. for (i = 0; i < num_fields; i++)
  806. {
  807. int num_bits = fields[i].num_bits;
  808. int num_bytes = CEIL(fields[i].num_bits, 8);
  809. (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
  810. (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
  811. (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
  812. (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
  813. (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
  814. (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
  815. (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
  816. (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
  817. (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
  818. }
  819. return ERROR_OK;
  820. }
  821. void jtag_add_tlr(void)
  822. {
  823. jtag_prelude(TAP_RESET);
  824. int retval;
  825. retval=interface_jtag_add_tlr();
  826. if (retval!=ERROR_OK)
  827. jtag_error=retval;
  828. }
  829. int MINIDRIVER(interface_jtag_add_tlr)()
  830. {
  831. enum tap_state state = TAP_RESET;
  832. jtag_command_t **last_cmd = jtag_get_last_command_p();
  833. /* allocate memory for a new list member */
  834. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  835. last_comand_pointer = &((*last_cmd)->next);
  836. (*last_cmd)->next = NULL;
  837. (*last_cmd)->type = JTAG_STATEMOVE;
  838. (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
  839. (*last_cmd)->cmd.statemove->end_state = state;
  840. return ERROR_OK;
  841. }
  842. void jtag_add_pathmove(int num_states, enum tap_state *path)
  843. {
  844. enum tap_state cur_state=cmd_queue_cur_state;
  845. int i;
  846. int retval;
  847. /* the last state has to be a stable state */
  848. if (tap_move_map[path[num_states - 1]] == -1)
  849. {
  850. LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
  851. exit(-1);
  852. }
  853. for (i=0; i<num_states; i++)
  854. {
  855. if (path[i] == TAP_RESET)
  856. {
  857. LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
  858. exit(-1);
  859. }
  860. if ((tap_transitions[cur_state].low != path[i])&&
  861. (tap_transitions[cur_state].high != path[i]))
  862. {
  863. LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(path[i]));
  864. exit(-1);
  865. }
  866. cur_state = path[i];
  867. }
  868. jtag_prelude1();
  869. retval=interface_jtag_add_pathmove(num_states, path);
  870. cmd_queue_cur_state = path[num_states - 1];
  871. if (retval!=ERROR_OK)
  872. jtag_error=retval;
  873. }
  874. int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path)
  875. {
  876. jtag_command_t **last_cmd = jtag_get_last_command_p();
  877. int i;
  878. /* allocate memory for a new list member */
  879. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  880. last_comand_pointer = &((*last_cmd)->next);
  881. (*last_cmd)->next = NULL;
  882. (*last_cmd)->type = JTAG_PATHMOVE;
  883. (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
  884. (*last_cmd)->cmd.pathmove->num_states = num_states;
  885. (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states);
  886. for (i = 0; i < num_states; i++)
  887. (*last_cmd)->cmd.pathmove->path[i] = path[i];
  888. return ERROR_OK;
  889. }
  890. int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state)
  891. {
  892. jtag_command_t **last_cmd = jtag_get_last_command_p();
  893. /* allocate memory for a new list member */
  894. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  895. (*last_cmd)->next = NULL;
  896. last_comand_pointer = &((*last_cmd)->next);
  897. (*last_cmd)->type = JTAG_RUNTEST;
  898. (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
  899. (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
  900. (*last_cmd)->cmd.runtest->end_state = state;
  901. return ERROR_OK;
  902. }
  903. void jtag_add_runtest(int num_cycles, enum tap_state state)
  904. {
  905. int retval;
  906. jtag_prelude(state);
  907. /* executed by sw or hw fifo */
  908. retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
  909. if (retval!=ERROR_OK)
  910. jtag_error=retval;
  911. }
  912. void jtag_add_reset(int req_tlr_or_trst, int req_srst)
  913. {
  914. int trst_with_tlr = 0;
  915. int retval;
  916. /* FIX!!! there are *many* different cases here. A better
  917. * approach is needed for legal combinations of transitions...
  918. */
  919. if ((jtag_reset_config & RESET_HAS_SRST)&&
  920. (jtag_reset_config & RESET_HAS_TRST)&&
  921. ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
  922. {
  923. if (((req_tlr_or_trst&&!jtag_trst)||
  924. (!req_tlr_or_trst&&jtag_trst))&&
  925. ((req_srst&&!jtag_srst)||
  926. (!req_srst&&jtag_srst)))
  927. {
  928. /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
  929. //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
  930. }
  931. }
  932. /* Make sure that jtag_reset_config allows the requested reset */
  933. /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
  934. if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
  935. {
  936. LOG_ERROR("BUG: requested reset would assert trst");
  937. jtag_error=ERROR_FAIL;
  938. return;
  939. }
  940. /* if TRST pulls SRST, we reset with TAP T-L-R */
  941. if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
  942. {
  943. trst_with_tlr = 1;
  944. }
  945. if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
  946. {
  947. LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
  948. jtag_error=ERROR_FAIL;
  949. return;
  950. }
  951. if (req_tlr_or_trst)
  952. {
  953. if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
  954. {
  955. jtag_trst = 1;
  956. } else
  957. {
  958. trst_with_tlr = 1;
  959. }
  960. } else
  961. {
  962. jtag_trst = 0;
  963. }
  964. jtag_srst = req_srst;
  965. retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
  966. if (retval!=ERROR_OK)
  967. {
  968. jtag_error=retval;
  969. return;
  970. }
  971. if (jtag_srst)
  972. {
  973. LOG_DEBUG("SRST line asserted");
  974. }
  975. else
  976. {
  977. LOG_DEBUG("SRST line released");
  978. if (jtag_nsrst_delay)
  979. jtag_add_sleep(jtag_nsrst_delay * 1000);
  980. }
  981. if (trst_with_tlr)
  982. {
  983. LOG_DEBUG("JTAG reset with RESET instead of TRST");
  984. jtag_add_end_state(TAP_RESET);
  985. jtag_add_tlr();
  986. jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
  987. return;
  988. }
  989. if (jtag_trst)
  990. {
  991. /* we just asserted nTRST, so we're now in Test-Logic-Reset,
  992. * and inform possible listeners about this
  993. */
  994. LOG_DEBUG("TRST line asserted");
  995. cmd_queue_cur_state = TAP_RESET;
  996. jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
  997. }
  998. else
  999. {
  1000. if (jtag_ntrst_delay)
  1001. jtag_add_sleep(jtag_ntrst_delay * 1000);
  1002. }
  1003. }
  1004. int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
  1005. {
  1006. jtag_command_t **last_cmd = jtag_get_last_command_p();
  1007. /* allocate memory for a new list member */
  1008. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  1009. (*last_cmd)->next = NULL;
  1010. last_comand_pointer = &((*last_cmd)->next);
  1011. (*last_cmd)->type = JTAG_RESET;
  1012. (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
  1013. (*last_cmd)->cmd.reset->trst = req_trst;
  1014. (*last_cmd)->cmd.reset->srst = req_srst;
  1015. return ERROR_OK;
  1016. }
  1017. void jtag_add_end_state(enum tap_state state)
  1018. {
  1019. cmd_queue_end_state = state;
  1020. if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
  1021. {
  1022. LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
  1023. }
  1024. }
  1025. int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
  1026. {
  1027. jtag_command_t **last_cmd = jtag_get_last_command_p();
  1028. /* allocate memory for a new list member */
  1029. *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
  1030. (*last_cmd)->next = NULL;
  1031. last_comand_pointer = &((*last_cmd)->next);
  1032. (*last_cmd)->type = JTAG_SLEEP;
  1033. (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
  1034. (*last_cmd)->cmd.sleep->us = us;
  1035. return ERROR_OK;
  1036. }
  1037. void jtag_add_sleep(u32 us)
  1038. {
  1039. keep_alive(); /* we might be running on a very slow JTAG clk */
  1040. int retval=interface_jtag_add_sleep(us);
  1041. if (retval!=ERROR_OK)
  1042. jtag_error=retval;
  1043. return;
  1044. }
  1045. int jtag_scan_size(scan_command_t *cmd)
  1046. {
  1047. int bit_count = 0;
  1048. int i;
  1049. /* count bits in scan command */
  1050. for (i = 0; i < cmd->num_fields; i++)
  1051. {
  1052. bit_count += cmd->fields[i].num_bits;
  1053. }
  1054. return bit_count;
  1055. }
  1056. int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
  1057. {
  1058. int bit_count = 0;
  1059. int i;
  1060. bit_count = jtag_scan_size(cmd);
  1061. *buffer = malloc(CEIL(bit_count, 8));
  1062. bit_count = 0;
  1063. for (i = 0; i < cmd->num_fields; i++)
  1064. {
  1065. if (cmd->fields[i].out_value)
  1066. {
  1067. #ifdef _DEBUG_JTAG_IO_
  1068. char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16);
  1069. #endif
  1070. buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
  1071. #ifdef _DEBUG_JTAG_IO_
  1072. LOG_DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
  1073. free(char_buf);
  1074. #endif
  1075. }
  1076. bit_count += cmd->fields[i].num_bits;
  1077. }
  1078. return bit_count;
  1079. }
  1080. int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
  1081. {
  1082. int i;
  1083. int bit_count = 0;
  1084. int retval;
  1085. /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
  1086. retval = ERROR_OK;
  1087. for (i = 0; i < cmd->num_fields; i++)
  1088. {
  1089. /* if neither in_value nor in_handler
  1090. * are specified we don't have to examine this field
  1091. */
  1092. if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
  1093. {
  1094. int num_bits = cmd->fields[i].num_bits;
  1095. u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
  1096. #ifdef _DEBUG_JTAG_IO_
  1097. char *char_buf;
  1098. char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
  1099. LOG_DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
  1100. free(char_buf);
  1101. #endif
  1102. if (cmd->fields[i].in_value)
  1103. {
  1104. buf_cpy(captured, cmd->fields[i].in_value, num_bits);
  1105. if (cmd->fields[i].in_handler)
  1106. {
  1107. if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
  1108. {
  1109. LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
  1110. retval = ERROR_JTAG_QUEUE_FAILED;
  1111. }
  1112. }
  1113. }
  1114. /* no in_value specified, but a handler takes care of the scanned data */
  1115. if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
  1116. {
  1117. if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
  1118. {
  1119. /* We're going to call the error:handler later, but if the in_handler
  1120. * reported an error we report this failure upstream
  1121. */
  1122. LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
  1123. retval = ERROR_JTAG_QUEUE_FAILED;
  1124. }
  1125. }
  1126. free(captured);
  1127. }
  1128. bit_count += cmd->fields[i].num_bits;
  1129. }
  1130. return retval;
  1131. }
  1132. int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
  1133. {
  1134. int retval = ERROR_OK;
  1135. int num_bits = field->num_bits;
  1136. int compare_failed = 0;
  1137. if (field->in_check_mask)
  1138. compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
  1139. else
  1140. compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
  1141. if (compare_failed){
  1142. /* An error handler could have caught the failing check
  1143. * only report a problem when there wasn't a handler, or if the handler
  1144. * acknowledged the error
  1145. */
  1146. LOG_WARNING("TAP %s:",
  1147. (field->tap == NULL) ? "(unknown)" : field->tap->dotted_name );
  1148. if (compare_failed)
  1149. {
  1150. char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
  1151. char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16);
  1152. if (field->in_check_mask)
  1153. {
  1154. char *in_check_mask_char;
  1155. in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16);
  1156. LOG_WARNING("value captured during scan didn't pass the requested check:");
  1157. LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
  1158. captured_char, in_check_value_char, in_check_mask_char);
  1159. free(in_check_mask_char);
  1160. }
  1161. else
  1162. {
  1163. LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char);
  1164. }
  1165. free(captured_char);
  1166. free(in_check_value_char);
  1167. retval = ERROR_JTAG_QUEUE_FAILED;
  1168. }
  1169. }
  1170. return retval;
  1171. }
  1172. /*
  1173. set up checking of this field using the in_handler. The values passed in must be valid until
  1174. after jtag_execute() has completed.
  1175. */
  1176. void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
  1177. {
  1178. if (value)
  1179. field->in_handler = jtag_check_value;
  1180. else
  1181. field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
  1182. field->in_handler_priv = NULL;
  1183. field->in_check_value = value;
  1184. field->in_check_mask = mask;
  1185. }
  1186. enum scan_type jtag_scan_type(scan_command_t *cmd)
  1187. {
  1188. int i;
  1189. int type = 0;
  1190. for (i = 0; i < cmd->num_fields; i++)
  1191. {
  1192. if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
  1193. type |= SCAN_IN;
  1194. if (cmd->fields[i].out_value)
  1195. type |= SCAN_OUT;
  1196. }
  1197. return type;
  1198. }
  1199. int MINIDRIVER(interface_jtag_execute_queue)(void)
  1200. {
  1201. int retval;
  1202. if (jtag==NULL)
  1203. {
  1204. LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
  1205. return ERROR_FAIL;
  1206. }
  1207. retval = jtag->execute_queue();
  1208. cmd_queue_free();
  1209. jtag_command_queue = NULL;
  1210. last_comand_pointer = &jtag_command_queue;
  1211. return retval;
  1212. }
  1213. int jtag_execute_queue(void)
  1214. {
  1215. int retval=interface_jtag_execute_queue();
  1216. if (retval==ERROR_OK)
  1217. {
  1218. retval=jtag_error;
  1219. }
  1220. jtag_error=ERROR_OK;
  1221. return retval;
  1222. }
  1223. int jtag_reset_callback(enum jtag_event event, void *priv)
  1224. {
  1225. jtag_tap_t *tap = priv;
  1226. LOG_DEBUG("-");
  1227. if (event == JTAG_TRST_ASSERTED)
  1228. {
  1229. buf_set_ones(tap->cur_instr, tap->ir_length);
  1230. tap->bypass = 1;
  1231. }
  1232. return ERROR_OK;
  1233. }
  1234. void jtag_sleep(u32 us)
  1235. {
  1236. alive_sleep(us/1000);
  1237. }
  1238. /* Try to examine chain layout according to IEEE 1149.1 §12
  1239. */
  1240. int jtag_examine_chain(void)
  1241. {
  1242. jtag_tap_t *tap;
  1243. scan_field_t field;
  1244. u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
  1245. int i;
  1246. int bit_count;
  1247. int device_count = 0;
  1248. u8 zero_check = 0x0;
  1249. u8 one_check = 0xff;
  1250. field.tap = NULL;
  1251. field.num_bits = sizeof(idcode_buffer) * 8;
  1252. field.out_value = idcode_buffer;
  1253. field.out_mask = NULL;
  1254. field.in_value = idcode_buffer;
  1255. field.in_check_value = NULL;
  1256. field.in_check_mask = NULL;
  1257. field.in_handler = NULL;
  1258. field.in_handler_priv = NULL;
  1259. for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
  1260. {
  1261. buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
  1262. }
  1263. jtag_add_plain_dr_scan(1, &field, TAP_RESET);
  1264. jtag_execute_queue();
  1265. for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
  1266. {
  1267. zero_check |= idcode_buffer[i];
  1268. one_check &= idcode_buffer[i];
  1269. }
  1270. /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
  1271. if ((zero_check == 0x00) || (one_check == 0xff))
  1272. {
  1273. LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
  1274. return ERROR_JTAG_INIT_FAILED;
  1275. }
  1276. // point at the 1st tap
  1277. tap = jtag_NextEnabledTap(NULL);
  1278. if( tap == NULL ){
  1279. LOG_ERROR("JTAG: No taps enabled?");
  1280. return ERROR_JTAG_INIT_FAILED;
  1281. }
  1282. for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
  1283. {
  1284. u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
  1285. if ((idcode & 1) == 0)
  1286. {
  1287. /* LSB must not be 0, this indicates a device in bypass */
  1288. LOG_WARNING("Tap/Device does not have IDCODE");
  1289. idcode=0;
  1290. bit_count += 1;
  1291. }
  1292. else
  1293. {
  1294. u32 manufacturer;
  1295. u32 part;
  1296. u32 version;
  1297. if (idcode == 0x000000FF)
  1298. {
  1299. int unexpected=0;
  1300. /* End of chain (invalid manufacturer ID)
  1301. *
  1302. * The JTAG examine is the very first thing that happens
  1303. *
  1304. * A single JTAG device requires only 64 bits to be read back correctly.
  1305. *
  1306. * The code below adds a check that the rest of the data scanned (640 bits)
  1307. * are all as expected. This helps diagnose/catch problems with the JTAG chain
  1308. *
  1309. * earlier and gives more helpful/explicit error messages.
  1310. */
  1311. for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
  1312. {
  1313. idcode = buf_get_u32(idcode_buffer, bit_count, 32);
  1314. if (unexpected||(idcode != 0x000000FF))
  1315. {
  1316. LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
  1317. unexpected = 1;
  1318. }
  1319. }
  1320. break;
  1321. }
  1322. #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
  1323. manufacturer = EXTRACT_MFG(idcode);
  1324. #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
  1325. part = EXTRACT_PART(idcode);
  1326. #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
  1327. version = EXTRACT_VER(idcode);
  1328. LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
  1329. ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
  1330. idcode, manufacturer, part, version);
  1331. bit_count += 32;
  1332. }
  1333. if (tap)
  1334. {
  1335. tap->idcode = idcode;
  1336. if (tap->expected_ids_cnt > 0) {
  1337. /* Loop over the expected identification codes and test for a match */
  1338. u8 ii;
  1339. for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
  1340. if( tap->idcode == tap->expected_ids[ii] ){
  1341. break;
  1342. }
  1343. }
  1344. /* If none of the expected ids matched, log an error */
  1345. if (ii == tap->expected_ids_cnt) {
  1346. LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
  1347. tap->dotted_name,
  1348. idcode,
  1349. EXTRACT_MFG( tap->idcode ),
  1350. EXTRACT_PART( tap->idcode ),
  1351. EXTRACT_VER( tap->idcode ) );
  1352. for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
  1353. LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
  1354. tap->dotted_name,
  1355. ii + 1,
  1356. tap->expected_ids_cnt,
  1357. tap->expected_ids[ii],
  1358. EXTRACT_MFG( tap->expected_ids[ii] ),
  1359. EXTRACT_PART( tap->expected_ids[ii] ),
  1360. EXTRACT_VER( tap->expected_ids[ii] ) );
  1361. }
  1362. return ERROR_JTAG_INIT_FAILED;
  1363. } else {
  1364. LOG_INFO("JTAG Tap/device matched");
  1365. }
  1366. } else {
  1367. #if 0
  1368. LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
  1369. tap->idcode);
  1370. #endif
  1371. }
  1372. tap = jtag_NextEnabledTap(tap);
  1373. }
  1374. device_count++;
  1375. }
  1376. /* see if number of discovered devices matches configuration */
  1377. if (device_count != jtag_NumEnabledTaps())
  1378. {
  1379. LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
  1380. device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
  1381. LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
  1382. return ERROR_JTAG_INIT_FAILED;
  1383. }
  1384. return ERROR_OK;
  1385. }
  1386. int jtag_validate_chain(void)
  1387. {
  1388. jtag_tap_t *tap;
  1389. int total_ir_length = 0;
  1390. u8 *ir_test = NULL;
  1391. scan_field_t field;
  1392. int chain_pos = 0;
  1393. tap = NULL;
  1394. total_ir_length = 0;
  1395. for(;;){
  1396. tap = jtag_NextEnabledTap(tap);
  1397. if( tap == NULL ){
  1398. break;
  1399. }
  1400. total_ir_length += tap->ir_length;
  1401. }
  1402. total_ir_length += 2;
  1403. ir_test = malloc(CEIL(total_ir_length, 8));
  1404. buf_set_ones(ir_test, total_ir_length);
  1405. field.tap = NULL;
  1406. field.num_bits = total_ir_length;
  1407. field.out_value = ir_test;
  1408. field.out_mask = NULL;
  1409. field.in_value = ir_test;
  1410. field.in_check_value = NULL;
  1411. field.in_check_mask = NULL;
  1412. field.in_handler = NULL;
  1413. field.in_handler_priv = NULL;
  1414. jtag_add_plain_ir_scan(1, &field, TAP_RESET);
  1415. jtag_execute_queue();
  1416. tap = NULL;
  1417. chain_pos = 0;
  1418. for(;;){
  1419. tap = jtag_NextEnabledTap(tap);
  1420. if( tap == NULL ){
  1421. break;
  1422. }
  1423. if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
  1424. {
  1425. char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
  1426. LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
  1427. free(cbuf);
  1428. free(ir_test);
  1429. return ERROR_JTAG_INIT_FAILED;
  1430. }
  1431. chain_pos += tap->ir_length;
  1432. }
  1433. if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
  1434. {
  1435. char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
  1436. LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
  1437. free(cbuf);
  1438. free(ir_test);
  1439. return ERROR_JTAG_INIT_FAILED;
  1440. }
  1441. free(ir_test);
  1442. return ERROR_OK;
  1443. }
  1444. enum jtag_tap_cfg_param {
  1445. JCFG_EVENT
  1446. };
  1447. static Jim_Nvp nvp_config_opts[] = {
  1448. { .name = "-event", .value = JCFG_EVENT },
  1449. { .name = NULL, .value = -1 }
  1450. };
  1451. static int
  1452. jtag_tap_configure_cmd( Jim_GetOptInfo *goi,
  1453. jtag_tap_t * tap)
  1454. {
  1455. Jim_Nvp *n;
  1456. Jim_Obj *o;
  1457. int e;
  1458. /* parse config or cget options */
  1459. while (goi->argc > 0) {
  1460. Jim_SetEmptyResult (goi->interp);
  1461. e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
  1462. if (e != JIM_OK) {
  1463. Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
  1464. return e;
  1465. }
  1466. switch (n->value) {
  1467. case JCFG_EVENT:
  1468. if (goi->argc == 0) {
  1469. Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
  1470. return JIM_ERR;
  1471. }
  1472. e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
  1473. if (e != JIM_OK) {
  1474. Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
  1475. return e;
  1476. }
  1477. if (goi->isconfigure) {
  1478. if (goi->argc != 1) {
  1479. Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
  1480. return JIM_ERR;
  1481. }
  1482. } else {
  1483. if (goi->argc != 0) {
  1484. Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
  1485. return JIM_ERR;
  1486. }
  1487. }
  1488. {
  1489. jtag_tap_event_action_t *jteap;
  1490. jteap = tap->event_action;
  1491. /* replace existing? */
  1492. while (jteap) {
  1493. if (jteap->event == n->value) {
  1494. break;
  1495. }
  1496. jteap = jteap->next;
  1497. }
  1498. if (goi->isconfigure) {
  1499. if (jteap == NULL) {
  1500. /* create new */
  1501. jteap = calloc(1, sizeof (*jteap));
  1502. }
  1503. jteap->event = n->value;
  1504. Jim_GetOpt_Obj( goi, &o);
  1505. if (jteap->body) {
  1506. Jim_DecrRefCount(interp, jteap->body);
  1507. }
  1508. jteap->body = Jim_DuplicateObj(goi->interp, o);
  1509. Jim_IncrRefCount(jteap->body);
  1510. /* add to head of event list */
  1511. jteap->next = tap->event_action;
  1512. tap->event_action = jteap;
  1513. Jim_SetEmptyResult(goi->interp);
  1514. } else {
  1515. /* get */
  1516. if (jteap == NULL) {
  1517. Jim_SetEmptyResult(goi->interp);
  1518. } else {
  1519. Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
  1520. }
  1521. }
  1522. }
  1523. /* loop for more */
  1524. break;
  1525. }
  1526. } /* while (goi->argc) */
  1527. return JIM_OK;
  1528. }
  1529. static int jim_newtap_cmd( Jim_GetOptInfo *goi )
  1530. {
  1531. jtag_tap_t *pTap;
  1532. jtag_tap_t **ppTap;
  1533. jim_wide w;
  1534. int x;
  1535. int e;
  1536. int reqbits;
  1537. Jim_Nvp *n;
  1538. char *cp;
  1539. const Jim_Nvp opts[] = {
  1540. #define NTAP_OPT_IRLEN 0
  1541. { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
  1542. #define NTAP_OPT_IRMASK 1
  1543. { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
  1544. #define NTAP_OPT_IRCAPTURE 2
  1545. { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
  1546. #define NTAP_OPT_ENABLED 3
  1547. { .name = "-enable" , .value = NTAP_OPT_ENABLED },
  1548. #define NTAP_OPT_DISABLED 4
  1549. { .name = "-disable" , .value = NTAP_OPT_DISABLED },
  1550. #define NTAP_OPT_EXPECTED_ID 5
  1551. { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
  1552. { .name = NULL , .value = -1 },
  1553. };
  1554. pTap = malloc( sizeof(jtag_tap_t) );
  1555. memset( pTap, 0, sizeof(*pTap) );
  1556. if( !pTap ){
  1557. Jim_SetResult_sprintf( goi->interp, "no memory");
  1558. return JIM_ERR;
  1559. }
  1560. /*
  1561. * we expect CHIP + TAP + OPTIONS
  1562. * */
  1563. if( goi->argc < 3 ){
  1564. Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
  1565. return JIM_ERR;
  1566. }
  1567. Jim_GetOpt_String( goi, &cp, NULL );
  1568. pTap->chip = strdup(cp);
  1569. Jim_GetOpt_String( goi, &cp, NULL );
  1570. pTap->tapname = strdup(cp);
  1571. /* name + dot + name + null */
  1572. x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
  1573. cp = malloc( x );
  1574. sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
  1575. pTap->dotted_name = cp;
  1576. LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
  1577. pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
  1578. /* default is enabled */
  1579. pTap->enabled = 1;
  1580. /* deal with options */
  1581. #define NTREQ_IRLEN 1
  1582. #define NTREQ_IRCAPTURE 2
  1583. #define NTREQ_IRMASK 4
  1584. /* clear them as we find them */
  1585. reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
  1586. while( goi->argc ){
  1587. e = Jim_GetOpt_Nvp( goi, opts, &n );
  1588. if( e != JIM_OK ){
  1589. Jim_GetOpt_NvpUnknown( goi, opts, 0 );
  1590. return e;
  1591. }
  1592. LOG_DEBUG("Processing option: %s", n->name );
  1593. switch( n->value ){
  1594. case NTAP_OPT_ENABLED:
  1595. pTap->enabled = 1;
  1596. break;
  1597. case NTAP_OPT_DISABLED:
  1598. pTap->enabled = 0;
  1599. break;
  1600. case NTAP_OPT_EXPECTED_ID:
  1601. {
  1602. u32 *new_expected_ids;
  1603. e = Jim_GetOpt_Wide( goi, &w );
  1604. if( e != JIM_OK) {
  1605. Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
  1606. return e;
  1607. }
  1608. new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
  1609. if (new_expected_ids == NULL) {
  1610. Jim_SetResult_sprintf( goi->interp, "no memory");
  1611. return JIM_ERR;
  1612. }
  1613. memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
  1614. new_expected_ids[pTap->expected_ids_cnt] = w;
  1615. free(pTap->expected_ids);
  1616. pTap->expected_ids = new_expected_ids;
  1617. pTap->expected_ids_cnt++;
  1618. break;
  1619. }
  1620. case NTAP_OPT_IRLEN:
  1621. case NTAP_OPT_IRMASK:
  1622. case NTAP_OPT_IRCAPTURE:
  1623. e = Jim_GetOpt_Wide( goi, &w );
  1624. if( e != JIM_OK ){
  1625. Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
  1626. return e;
  1627. }
  1628. if( (w < 0) || (w > 0xffff) ){
  1629. /* wacky value */
  1630. Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
  1631. n->name, (int)(w), (int)(w));
  1632. return JIM_ERR;
  1633. }
  1634. switch(n->value){
  1635. case NTAP_OPT_IRLEN:
  1636. pTap->ir_length = w;
  1637. reqbits &= (~(NTREQ_IRLEN));
  1638. break;
  1639. case NTAP_OPT_IRMASK:
  1640. pTap->ir_capture_mask = w;
  1641. reqbits &= (~(NTREQ_IRMASK));
  1642. break;
  1643. case NTAP_OPT_IRCAPTURE:
  1644. pTap->ir_capture_value = w;
  1645. reqbits &= (~(NTREQ_IRCAPTURE));
  1646. break;
  1647. }
  1648. } /* switch(n->value) */
  1649. } /* while( goi->argc ) */
  1650. /* Did we get all the options? */
  1651. if( reqbits ){
  1652. // no
  1653. Jim_SetResult_sprintf( goi->interp,
  1654. "newtap: %s missing required parameters",
  1655. pTap->dotted_name);
  1656. /* TODO: Tell user what is missing :-( */
  1657. /* no memory leaks pelase */
  1658. free(((void *)(pTap->expected_ids)));
  1659. free(((void *)(pTap->chip)));
  1660. free(((void *)(pTap->tapname)));
  1661. free(((void *)(pTap->dotted_name)));
  1662. free(((void *)(pTap)));
  1663. return JIM_ERR;
  1664. }
  1665. pTap->expected = malloc( pTap->ir_length );
  1666. pTap->expected_mask = malloc( pTap->ir_length );
  1667. pTap->cur_instr = malloc( pTap->ir_length );
  1668. buf_set_u32( pTap->expected,
  1669. 0,
  1670. pTap->ir_length,
  1671. pTap->ir_capture_value );
  1672. buf_set_u32( pTap->expected_mask,
  1673. 0,
  1674. pTap->ir_length,
  1675. pTap->ir_capture_mask );
  1676. buf_set_ones( pTap->cur_instr,
  1677. pTap->ir_length );
  1678. pTap->bypass = 1;
  1679. jtag_register_event_callback(jtag_reset_callback, pTap );
  1680. ppTap = &(jtag_all_taps);
  1681. while( (*ppTap) != NULL ){
  1682. ppTap = &((*ppTap)->next_tap);
  1683. }
  1684. *ppTap = pTap;
  1685. {
  1686. static int n_taps = 0;
  1687. pTap->abs_chain_position = n_taps++;
  1688. }
  1689. LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
  1690. (*ppTap)->dotted_name,
  1691. (*ppTap)->abs_chain_position,
  1692. (*ppTap)->ir_length,
  1693. (*ppTap)->ir_capture_value,
  1694. (*ppTap)->ir_capture_mask );
  1695. return ERROR_OK;
  1696. }
  1697. static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
  1698. {
  1699. Jim_GetOptInfo goi;
  1700. int e;
  1701. Jim_Nvp *n;
  1702. Jim_Obj *o;
  1703. struct command_context_s *context;
  1704. enum {
  1705. JTAG_CMD_INTERFACE,
  1706. JTAG_CMD_INIT_RESET,
  1707. JTAG_CMD_NEWTAP,
  1708. JTAG_CMD_TAPENABLE,
  1709. JTAG_CMD_TAPDISABLE,
  1710. JTAG_CMD_TAPISENABLED,
  1711. JTAG_CMD_CONFIGURE,
  1712. JTAG_CMD_CGET
  1713. };
  1714. const Jim_Nvp jtag_cmds[] = {
  1715. { .name = "interface" , .value = JTAG_CMD_INTERFACE },
  1716. { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
  1717. { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
  1718. { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
  1719. { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
  1720. { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
  1721. { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
  1722. { .name = "cget" , .value = JTAG_CMD_CGET },
  1723. { .name = NULL, .value = -1 },
  1724. };
  1725. context = Jim_GetAssocData(interp, "context");
  1726. /* go past the command */
  1727. Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
  1728. e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
  1729. if( e != JIM_OK ){
  1730. Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
  1731. return e;
  1732. }
  1733. Jim_SetEmptyResult( goi.interp );
  1734. switch( n->value ){
  1735. case JTAG_CMD_INTERFACE:
  1736. /* return the name of the interface */
  1737. /* TCL code might need to know the exact type... */
  1738. /* FUTURE: we allow this as a means to "set" the interface. */
  1739. if( goi.argc != 0 ){
  1740. Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
  1741. return JIM_ERR;
  1742. }
  1743. Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
  1744. return JIM_OK;
  1745. case JTAG_CMD_INIT_RESET:
  1746. if( goi.argc != 0 ){
  1747. Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
  1748. return JIM_ERR;
  1749. }
  1750. e = jtag_init_reset(context);
  1751. if( e != ERROR_OK ){
  1752. Jim_SetResult_sprintf( goi.interp, "error: %d", e);
  1753. return JIM_ERR;
  1754. }
  1755. return JIM_OK;
  1756. case JTAG_CMD_NEWTAP:
  1757. return jim_newtap_cmd( &goi );
  1758. break;
  1759. case JTAG_CMD_TAPISENABLED:
  1760. case JTAG_CMD_TAPENABLE:
  1761. case JTAG_CMD_TAPDISABLE:
  1762. if( goi.argc != 1 ){
  1763. Jim_SetResultString( goi.interp, "Too many parameters",-1 );
  1764. return JIM_ERR;
  1765. }
  1766. {
  1767. jtag_tap_t *t;
  1768. t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
  1769. if( t == NULL ){
  1770. return JIM_ERR;
  1771. }
  1772. switch( n->value ){
  1773. case JTAG_CMD_TAPISENABLED:
  1774. // below
  1775. break;
  1776. case JTAG_CMD_TAPENABLE:
  1777. jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
  1778. e = 1;
  1779. t->enabled = e;
  1780. break;
  1781. case JTAG_CMD_TAPDISABLE:
  1782. jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
  1783. e = 0;
  1784. t->enabled = e;
  1785. break;
  1786. }
  1787. Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
  1788. return JIM_OK;
  1789. }
  1790. break;
  1791. case JTAG_CMD_CGET:
  1792. if( goi.argc < 2 ){
  1793. Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
  1794. return JIM_ERR;
  1795. }
  1796. {
  1797. jtag_tap_t *t;
  1798. Jim_GetOpt_Obj(&goi, &o);
  1799. t = jtag_TapByJimObj( goi.interp, o );
  1800. if( t == NULL ){
  1801. return JIM_ERR;
  1802. }
  1803. goi.isconfigure = 0;
  1804. return jtag_tap_configure_cmd( &goi, t);
  1805. }
  1806. break;
  1807. case JTAG_CMD_CONFIGURE:
  1808. if( goi.argc < 3 ){
  1809. Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
  1810. return JIM_ERR;
  1811. }
  1812. {
  1813. jtag_tap_t *t;
  1814. Jim_GetOpt_Obj(&goi, &o);
  1815. t = jtag_TapByJimObj( goi.interp, o );
  1816. if( t == NULL ){
  1817. return JIM_ERR;
  1818. }
  1819. goi.isconfigure = 1;
  1820. return jtag_tap_configure_cmd( &goi, t);
  1821. }
  1822. }
  1823. return JIM_ERR;
  1824. }
  1825. int jtag_register_commands(struct command_context_s *cmd_ctx)
  1826. {
  1827. register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
  1828. register_command(cmd_ctx, NULL, "interface", handle_interface_command,
  1829. COMMAND_CONFIG, "try to configure interface");
  1830. register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
  1831. COMMAND_ANY, "set jtag speed (if supported)");
  1832. register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
  1833. COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
  1834. register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
  1835. COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
  1836. register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
  1837. COMMAND_CONFIG, NULL);
  1838. register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
  1839. COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
  1840. register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
  1841. COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
  1842. register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
  1843. COMMAND_EXEC, "print current scan chain configuration");
  1844. register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
  1845. COMMAND_EXEC, "finish JTAG operations in <tap_state>");
  1846. register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
  1847. COMMAND_EXEC, "toggle reset lines <trst> <srst>");
  1848. register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
  1849. COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
  1850. register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
  1851. COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
  1852. register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
  1853. register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
  1854. COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
  1855. return ERROR_OK;
  1856. }
  1857. int jtag_interface_init(struct command_context_s *cmd_ctx)
  1858. {
  1859. if (jtag)
  1860. return ERROR_OK;
  1861. if (!jtag_interface)
  1862. {
  1863. /* nothing was previously specified by "interface" command */
  1864. LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
  1865. return ERROR_JTAG_INVALID_INTERFACE;
  1866. }
  1867. if(hasKHz)
  1868. {
  1869. jtag_interface->khz(speed_khz, &jtag_speed);
  1870. hasKHz = 0;
  1871. }
  1872. if (jtag_interface->init() != ERROR_OK)
  1873. return ERROR_JTAG_INIT_FAILED;
  1874. jtag = jtag_interface;
  1875. return ERROR_OK;
  1876. }
  1877. static int jtag_init_inner(struct command_context_s *cmd_ctx)
  1878. {
  1879. jtag_tap_t *tap;
  1880. int retval;
  1881. LOG_DEBUG("Init JTAG chain");
  1882. tap = jtag_NextEnabledTap(NULL);
  1883. if( tap == NULL ){
  1884. LOG_ERROR("There are no enabled taps?");
  1885. return ERROR_JTAG_INIT_FAILED;
  1886. }
  1887. jtag_add_tlr();
  1888. if ((retval=jtag_execute_queue())!=ERROR_OK)
  1889. return retval;
  1890. /* examine chain first, as this could discover the real chain layout */
  1891. if (jtag_examine_chain() != ERROR_OK)
  1892. {
  1893. LOG_ERROR("trying to validate configured JTAG chain anyway...");
  1894. }
  1895. if (jtag_validate_chain() != ERROR_OK)
  1896. {
  1897. LOG_ERROR("Could not validate JTAG chain, continuing anyway...");
  1898. }
  1899. return ERROR_OK;
  1900. }
  1901. int jtag_init_reset(struct command_context_s *cmd_ctx)
  1902. {
  1903. int retval;
  1904. if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
  1905. return retval;
  1906. LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
  1907. /* Reset can happen after a power cycle.
  1908. *
  1909. * Ideally we would only assert TRST or run RESET before the target reset.
  1910. *
  1911. * However w/srst_pulls_trst, trst is asserted together with the target
  1912. * reset whether we want it or not.
  1913. *
  1914. * NB! Some targets have JTAG circuitry disabled until a
  1915. * trst & srst has been asserted.
  1916. *
  1917. * NB! here we assume nsrst/ntrst delay are sufficient!
  1918. *
  1919. * NB! order matters!!!! srst *can* disconnect JTAG circuitry
  1920. *
  1921. */
  1922. jtag_add_reset(1, 0); /* RESET or TRST */
  1923. if (jtag_reset_config & RESET_HAS_SRST)
  1924. {
  1925. jtag_add_reset(1, 1);
  1926. if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
  1927. jtag_add_reset(0, 1);
  1928. }
  1929. jtag_add_reset(0, 0);
  1930. if ((retval = jtag_execute_queue()) != ERROR_OK)
  1931. return retval;
  1932. /* Check that we can communication on the JTAG chain + eventually we want to
  1933. * be able to perform enumeration only after OpenOCD has started
  1934. * telnet and GDB server
  1935. *
  1936. * That would allow users to more easily perform any magic they need to before
  1937. * reset happens.
  1938. */
  1939. return jtag_init_inner(cmd_ctx);
  1940. }
  1941. int jtag_init(struct command_context_s *cmd_ctx)
  1942. {
  1943. int retval;
  1944. if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
  1945. return retval;
  1946. if (jtag_init_inner(cmd_ctx)==ERROR_OK)
  1947. {
  1948. return ERROR_OK;
  1949. }
  1950. return jtag_init_reset(cmd_ctx);
  1951. }
  1952. static int default_khz(int khz, int *jtag_speed)
  1953. {
  1954. LOG_ERROR("Translation from khz to jtag_speed not implemented");
  1955. return ERROR_FAIL;
  1956. }
  1957. static int default_speed_div(int speed, int *khz)
  1958. {
  1959. LOG_ERROR("Translation from jtag_speed to khz not implemented");
  1960. return ERROR_FAIL;
  1961. }
  1962. static int default_power_dropout(int *dropout)
  1963. {
  1964. *dropout=0; /* by default we can't detect power dropout */
  1965. return ERROR_OK;
  1966. }
  1967. static int default_srst_asserted(int *srst_asserted)
  1968. {
  1969. *srst_asserted=0; /* by default we can't detect srst asserted */
  1970. return ERROR_OK;
  1971. }
  1972. int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  1973. {
  1974. int i;
  1975. int retval;
  1976. /* check whether the interface is already configured */
  1977. if (jtag_interface)
  1978. {
  1979. LOG_WARNING("Interface already configured, ignoring");
  1980. return ERROR_OK;
  1981. }
  1982. /* interface name is a mandatory argument */
  1983. if (argc < 1 || args[0][0] == '\0')
  1984. {
  1985. return ERROR_COMMAND_SYNTAX_ERROR;
  1986. }
  1987. for (i=0; jtag_interfaces[i]; i++)
  1988. {
  1989. if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
  1990. {
  1991. if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
  1992. {
  1993. return retval;
  1994. }
  1995. jtag_interface = jtag_interfaces[i];
  1996. if (jtag_interface->khz == NULL)
  1997. {
  1998. jtag_interface->khz = default_khz;
  1999. }
  2000. if (jtag_interface->speed_div == NULL)
  2001. {
  2002. jtag_interface->speed_div = default_speed_div;
  2003. }
  2004. if (jtag_interface->power_dropout == NULL)
  2005. {
  2006. jtag_interface->power_dropout = default_power_dropout;
  2007. }
  2008. if (jtag_interface->srst_asserted == NULL)
  2009. {
  2010. jtag_interface->srst_asserted = default_srst_asserted;
  2011. }
  2012. return ERROR_OK;
  2013. }
  2014. }
  2015. /* no valid interface was found (i.e. the configuration option,
  2016. * didn't match one of the compiled-in interfaces
  2017. */
  2018. LOG_ERROR("No valid jtag interface found (%s)", args[0]);
  2019. LOG_ERROR("compiled-in jtag interfaces:");
  2020. for (i = 0; jtag_interfaces[i]; i++)
  2021. {
  2022. LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
  2023. }
  2024. return ERROR_JTAG_INVALID_INTERFACE;
  2025. }
  2026. int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2027. {
  2028. int e;
  2029. char buf[1024];
  2030. Jim_Obj *newargs[ 10 ];
  2031. /*
  2032. * CONVERT SYNTAX
  2033. * argv[-1] = command
  2034. * argv[ 0] = ir length
  2035. * argv[ 1] = ir capture
  2036. * argv[ 2] = ir mask
  2037. * argv[ 3] = not actually used by anything but in the docs
  2038. */
  2039. if( argc < 4 ){
  2040. command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
  2041. return ERROR_OK;
  2042. }
  2043. command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
  2044. command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
  2045. args[0],
  2046. args[1],
  2047. args[2] );
  2048. command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundryscan(len5)");
  2049. command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
  2050. command_print( cmd_ctx, "jtag newtap stm32 boundry ....., and the tap: \"stm32.boundery\"");
  2051. command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
  2052. newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
  2053. newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
  2054. sprintf( buf, "chip%d", jtag_NumTotalTaps() );
  2055. newargs[2] = Jim_NewStringObj( interp, buf, -1 );
  2056. sprintf( buf, "tap%d", jtag_NumTotalTaps() );
  2057. newargs[3] = Jim_NewStringObj( interp, buf, -1 );
  2058. newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
  2059. newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
  2060. newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
  2061. newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
  2062. newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
  2063. newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
  2064. command_print( cmd_ctx, "NEW COMMAND:");
  2065. sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
  2066. Jim_GetString( newargs[0], NULL ),
  2067. Jim_GetString( newargs[1], NULL ),
  2068. Jim_GetString( newargs[2], NULL ),
  2069. Jim_GetString( newargs[3], NULL ),
  2070. Jim_GetString( newargs[4], NULL ),
  2071. Jim_GetString( newargs[5], NULL ),
  2072. Jim_GetString( newargs[6], NULL ),
  2073. Jim_GetString( newargs[7], NULL ),
  2074. Jim_GetString( newargs[8], NULL ),
  2075. Jim_GetString( newargs[9], NULL ) );
  2076. e = jim_jtag_command( interp, 10, newargs );
  2077. if( e != JIM_OK ){
  2078. command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
  2079. }
  2080. return e;
  2081. }
  2082. int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2083. {
  2084. jtag_tap_t *tap;
  2085. tap = jtag_all_taps;
  2086. command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
  2087. command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
  2088. while( tap ){
  2089. u32 expected, expected_mask, cur_instr, ii;
  2090. expected = buf_get_u32(tap->expected, 0, tap->ir_length);
  2091. expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
  2092. cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
  2093. command_print(cmd_ctx,
  2094. "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
  2095. tap->abs_chain_position,
  2096. tap->dotted_name,
  2097. tap->enabled ? 'Y' : 'n',
  2098. tap->idcode,
  2099. (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
  2100. tap->ir_length,
  2101. expected,
  2102. expected_mask,
  2103. cur_instr);
  2104. for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
  2105. command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
  2106. tap->expected_ids[ii]);
  2107. }
  2108. tap = tap->next_tap;
  2109. }
  2110. return ERROR_OK;
  2111. }
  2112. int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2113. {
  2114. if (argc < 1)
  2115. return ERROR_COMMAND_SYNTAX_ERROR;
  2116. if (argc >= 1)
  2117. {
  2118. if (strcmp(args[0], "none") == 0)
  2119. jtag_reset_config = RESET_NONE;
  2120. else if (strcmp(args[0], "trst_only") == 0)
  2121. jtag_reset_config = RESET_HAS_TRST;
  2122. else if (strcmp(args[0], "srst_only") == 0)
  2123. jtag_reset_config = RESET_HAS_SRST;
  2124. else if (strcmp(args[0], "trst_and_srst") == 0)
  2125. jtag_reset_config = RESET_TRST_AND_SRST;
  2126. else
  2127. {
  2128. LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
  2129. jtag_reset_config = RESET_NONE;
  2130. return ERROR_INVALID_ARGUMENTS;
  2131. }
  2132. }
  2133. if (argc >= 2)
  2134. {
  2135. if (strcmp(args[1], "separate") == 0)
  2136. {
  2137. /* seperate reset lines - default */
  2138. } else
  2139. {
  2140. if (strcmp(args[1], "srst_pulls_trst") == 0)
  2141. jtag_reset_config |= RESET_SRST_PULLS_TRST;
  2142. else if (strcmp(args[1], "trst_pulls_srst") == 0)
  2143. jtag_reset_config |= RESET_TRST_PULLS_SRST;
  2144. else if (strcmp(args[1], "combined") == 0)
  2145. jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
  2146. else
  2147. {
  2148. LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
  2149. jtag_reset_config = RESET_NONE;
  2150. return ERROR_INVALID_ARGUMENTS;
  2151. }
  2152. }
  2153. }
  2154. if (argc >= 3)
  2155. {
  2156. if (strcmp(args[2], "trst_open_drain") == 0)
  2157. jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
  2158. else if (strcmp(args[2], "trst_push_pull") == 0)
  2159. jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
  2160. else
  2161. {
  2162. LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
  2163. jtag_reset_config = RESET_NONE;
  2164. return ERROR_INVALID_ARGUMENTS;
  2165. }
  2166. }
  2167. if (argc >= 4)
  2168. {
  2169. if (strcmp(args[3], "srst_push_pull") == 0)
  2170. jtag_reset_config |= RESET_SRST_PUSH_PULL;
  2171. else if (strcmp(args[3], "srst_open_drain") == 0)
  2172. jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
  2173. else
  2174. {
  2175. LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
  2176. jtag_reset_config = RESET_NONE;
  2177. return ERROR_INVALID_ARGUMENTS;
  2178. }
  2179. }
  2180. return ERROR_OK;
  2181. }
  2182. int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2183. {
  2184. if (argc < 1)
  2185. {
  2186. LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
  2187. exit(-1);
  2188. }
  2189. else
  2190. {
  2191. jtag_nsrst_delay = strtoul(args[0], NULL, 0);
  2192. }
  2193. return ERROR_OK;
  2194. }
  2195. int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2196. {
  2197. if (argc < 1)
  2198. {
  2199. LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
  2200. exit(-1);
  2201. }
  2202. else
  2203. {
  2204. jtag_ntrst_delay = strtoul(args[0], NULL, 0);
  2205. }
  2206. return ERROR_OK;
  2207. }
  2208. int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2209. {
  2210. int retval=ERROR_OK;
  2211. if (argc == 1)
  2212. {
  2213. LOG_DEBUG("handle jtag speed");
  2214. int cur_speed = 0;
  2215. cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
  2216. /* this command can be called during CONFIG,
  2217. * in which case jtag isn't initialized */
  2218. if (jtag)
  2219. {
  2220. retval=jtag->speed(cur_speed);
  2221. }
  2222. } else if (argc == 0)
  2223. {
  2224. } else
  2225. {
  2226. return ERROR_COMMAND_SYNTAX_ERROR;
  2227. }
  2228. command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
  2229. return retval;
  2230. }
  2231. int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2232. {
  2233. int retval=ERROR_OK;
  2234. LOG_DEBUG("handle jtag khz");
  2235. if(argc == 1)
  2236. {
  2237. speed_khz = strtoul(args[0], NULL, 0);
  2238. if (jtag != NULL)
  2239. {
  2240. int cur_speed = 0;
  2241. LOG_DEBUG("have interface set up");
  2242. int speed_div1;
  2243. if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
  2244. {
  2245. speed_khz = 0;
  2246. return retval;
  2247. }
  2248. cur_speed = jtag_speed = speed_div1;
  2249. retval=jtag->speed(cur_speed);
  2250. } else
  2251. {
  2252. hasKHz = 1;
  2253. }
  2254. } else if (argc==0)
  2255. {
  2256. } else
  2257. {
  2258. return ERROR_COMMAND_SYNTAX_ERROR;
  2259. }
  2260. if (jtag!=NULL)
  2261. {
  2262. if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
  2263. return retval;
  2264. }
  2265. if (speed_khz==0)
  2266. {
  2267. command_print(cmd_ctx, "RCLK - adaptive");
  2268. } else
  2269. {
  2270. command_print(cmd_ctx, "%d kHz", speed_khz);
  2271. }
  2272. return retval;
  2273. }
  2274. int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2275. {
  2276. enum tap_state state;
  2277. if (argc < 1)
  2278. {
  2279. return ERROR_COMMAND_SYNTAX_ERROR;
  2280. }
  2281. else
  2282. {
  2283. for (state = 0; state < 16; state++)
  2284. {
  2285. if (strcmp(args[0], jtag_state_name(state)) == 0)
  2286. {
  2287. jtag_add_end_state(state);
  2288. jtag_execute_queue();
  2289. }
  2290. }
  2291. }
  2292. command_print(cmd_ctx, "current endstate: %s", jtag_state_name(cmd_queue_end_state));
  2293. return ERROR_OK;
  2294. }
  2295. int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2296. {
  2297. int trst = -1;
  2298. int srst = -1;
  2299. if (argc < 2)
  2300. {
  2301. return ERROR_COMMAND_SYNTAX_ERROR;
  2302. }
  2303. if (args[0][0] == '1')
  2304. trst = 1;
  2305. else if (args[0][0] == '0')
  2306. trst = 0;
  2307. else
  2308. {
  2309. return ERROR_COMMAND_SYNTAX_ERROR;
  2310. }
  2311. if (args[1][0] == '1')
  2312. srst = 1;
  2313. else if (args[1][0] == '0')
  2314. srst = 0;
  2315. else
  2316. {
  2317. return ERROR_COMMAND_SYNTAX_ERROR;
  2318. }
  2319. if (jtag_interface_init(cmd_ctx) != ERROR_OK)
  2320. return ERROR_JTAG_INIT_FAILED;
  2321. jtag_add_reset(trst, srst);
  2322. jtag_execute_queue();
  2323. return ERROR_OK;
  2324. }
  2325. int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2326. {
  2327. if (argc < 1)
  2328. {
  2329. return ERROR_COMMAND_SYNTAX_ERROR;
  2330. }
  2331. jtag_add_runtest(strtol(args[0], NULL, 0), -1);
  2332. jtag_execute_queue();
  2333. return ERROR_OK;
  2334. }
  2335. int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2336. {
  2337. int i;
  2338. scan_field_t *fields;
  2339. jtag_tap_t *tap;
  2340. if ((argc < 2) || (argc % 2))
  2341. {
  2342. return ERROR_COMMAND_SYNTAX_ERROR;
  2343. }
  2344. fields = malloc(sizeof(scan_field_t) * argc / 2);
  2345. for (i = 0; i < argc / 2; i++)
  2346. {
  2347. tap = jtag_TapByString( args[i*2] );
  2348. if (tap==NULL)
  2349. {
  2350. command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
  2351. return ERROR_FAIL;
  2352. }
  2353. int field_size = tap->ir_length;
  2354. fields[i].tap = tap;
  2355. fields[i].out_value = malloc(CEIL(field_size, 8));
  2356. buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
  2357. fields[i].out_mask = NULL;
  2358. fields[i].in_value = NULL;
  2359. fields[i].in_check_mask = NULL;
  2360. fields[i].in_handler = NULL;
  2361. fields[i].in_handler_priv = NULL;
  2362. }
  2363. jtag_add_ir_scan(argc / 2, fields, -1);
  2364. jtag_execute_queue();
  2365. for (i = 0; i < argc / 2; i++)
  2366. free(fields[i].out_value);
  2367. free (fields);
  2368. return ERROR_OK;
  2369. }
  2370. int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
  2371. {
  2372. int retval;
  2373. scan_field_t *fields;
  2374. int num_fields;
  2375. int field_count = 0;
  2376. int i, e;
  2377. jtag_tap_t *tap;
  2378. /* args[1] = device
  2379. * args[2] = num_bits
  2380. * args[3] = hex string
  2381. * ... repeat num bits and hex string ...
  2382. */
  2383. if ((argc < 4) || ((argc % 2)!=0))
  2384. {
  2385. Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
  2386. return JIM_ERR;
  2387. }
  2388. for (i = 2; i < argc; i+=2)
  2389. {
  2390. long bits;
  2391. e = Jim_GetLong(interp, args[i], &bits);
  2392. if (e != JIM_OK)
  2393. return e;
  2394. }
  2395. tap = jtag_TapByJimObj( interp, args[1] );
  2396. if( tap == NULL ){
  2397. return JIM_ERR;
  2398. }
  2399. num_fields=(argc-2)/2;
  2400. fields = malloc(sizeof(scan_field_t) * num_fields);
  2401. for (i = 2; i < argc; i+=2)
  2402. {
  2403. long bits;
  2404. int len;
  2405. const char *str;
  2406. Jim_GetLong(interp, args[i], &bits);
  2407. str = Jim_GetString(args[i+1], &len);
  2408. fields[field_count].tap = tap;
  2409. fields[field_count].num_bits = bits;
  2410. fields[field_count].out_value = malloc(CEIL(bits, 8));
  2411. str_to_buf(str, len, fields[field_count].out_value, bits, 0);
  2412. fields[field_count].out_mask = NULL;
  2413. fields[field_count].in_value = fields[field_count].out_value;
  2414. fields[field_count].in_check_mask = NULL;
  2415. fields[field_count].in_check_value = NULL;
  2416. fields[field_count].in_handler = NULL;
  2417. fields[field_count++].in_handler_priv = NULL;
  2418. }
  2419. jtag_add_dr_scan(num_fields, fields, -1);
  2420. retval = jtag_execute_queue();
  2421. if (retval != ERROR_OK)
  2422. {
  2423. Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
  2424. return JIM_ERR;
  2425. }
  2426. field_count=0;
  2427. Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
  2428. for (i = 2; i < argc; i+=2)
  2429. {
  2430. long bits;
  2431. char *str;
  2432. Jim_GetLong(interp, args[i], &bits);
  2433. str = buf_to_str(fields[field_count].in_value, bits, 16);
  2434. free(fields[field_count].out_value);
  2435. Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
  2436. free(str);
  2437. field_count++;
  2438. }
  2439. Jim_SetResult(interp, list);
  2440. free(fields);
  2441. return JIM_OK;
  2442. }
  2443. int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  2444. {
  2445. if (argc == 1)
  2446. {
  2447. if (strcmp(args[0], "enable") == 0)
  2448. {
  2449. jtag_verify_capture_ir = 1;
  2450. }
  2451. else if (strcmp(args[0], "disable") == 0)
  2452. {
  2453. jtag_verify_capture_ir = 0;
  2454. } else
  2455. {
  2456. return ERROR_COMMAND_SYNTAX_ERROR;
  2457. }
  2458. } else if (argc != 0)
  2459. {
  2460. return ERROR_COMMAND_SYNTAX_ERROR;
  2461. }
  2462. command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
  2463. return ERROR_OK;
  2464. }
  2465. int jtag_power_dropout(int *dropout)
  2466. {
  2467. return jtag->power_dropout(dropout);
  2468. }
  2469. int jtag_srst_asserted(int *srst_asserted)
  2470. {
  2471. return jtag->srst_asserted(srst_asserted);
  2472. }
  2473. void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
  2474. {
  2475. jtag_tap_event_action_t * jteap;
  2476. int done;
  2477. jteap = tap->event_action;
  2478. done = 0;
  2479. while (jteap) {
  2480. if (jteap->event == e) {
  2481. done = 1;
  2482. LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
  2483. tap->dotted_name,
  2484. e,
  2485. Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
  2486. Jim_GetString(jteap->body, NULL) );
  2487. if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
  2488. Jim_PrintErrorMessage(interp);
  2489. }
  2490. }
  2491. jteap = jteap->next;
  2492. }
  2493. if (!done) {
  2494. LOG_DEBUG( "event %d %s - no action",
  2495. e,
  2496. Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
  2497. }
  2498. }
  2499. /* map state number to SVF state string */
  2500. const char* jtag_state_name(enum tap_state state)
  2501. {
  2502. const char* ret;
  2503. switch( state )
  2504. {
  2505. case TAP_RESET: ret = "RESET"; break;
  2506. case TAP_IDLE: ret = "IDLE"; break;
  2507. case TAP_DRSELECT: ret = "DRSELECT"; break;
  2508. case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
  2509. case TAP_DRSHIFT: ret = "DRSHIFT"; break;
  2510. case TAP_DREXIT1: ret = "DREXIT1"; break;
  2511. case TAP_DRPAUSE: ret = "DRPAUSE"; break;
  2512. case TAP_DREXIT2: ret = "DREXIT2"; break;
  2513. case TAP_DRUPDATE: ret = "DRUPDATE"; break;
  2514. case TAP_IRSELECT: ret = "IRSELECT"; break;
  2515. case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
  2516. case TAP_IRSHIFT: ret = "IRSHIFT"; break;
  2517. case TAP_IREXIT1: ret = "IREXIT1"; break;
  2518. case TAP_IRPAUSE: ret = "IRPAUSE"; break;
  2519. case TAP_IREXIT2: ret = "IREXIT2"; break;
  2520. case TAP_IRUPDATE: ret = "IRUPDATE"; break;
  2521. default: ret = "???";
  2522. }
  2523. return ret;
  2524. }