1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2009 SoftPLC Corporation *
12 * Copyright (C) 2009 Zachary T Welch *
13 * zw@superlucidity.net *
15 * This program is free software; you can redistribute it and/or modify *
16 * it under the terms of the GNU General Public License as published by *
17 * the Free Software Foundation; either version 2 of the License, or *
18 * (at your option) any later version. *
20 * This program is distributed in the hope that it will be useful, *
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
23 * GNU General Public License for more details. *
25 * You should have received a copy of the GNU General Public License *
26 * along with this program; if not, write to the *
27 * Free Software Foundation, Inc., *
28 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
29 ***************************************************************************/
35 #include "minidriver.h"
36 #include "interface.h"
43 /// The number of JTAG queue flushes (for profiling and debugging purposes).
44 static int jtag_flush_queue_count
;
46 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
47 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
);
50 * The jtag_error variable is set when an error occurs while executing
51 * the queue. Application code may set this using jtag_set_error(),
52 * when an error occurs during processing that should be reported during
53 * jtag_execute_queue().
55 * Tts value may be checked with jtag_get_error() and cleared with
56 * jtag_error_clear(). This value is returned (and cleared) by
57 * jtag_execute_queue().
59 static int jtag_error
= ERROR_OK
;
61 static const char *jtag_event_strings
[] =
63 [JTAG_TRST_ASSERTED
] = "JTAG controller reset (RESET or TRST)",
64 [JTAG_TAP_EVENT_ENABLE
] = "TAP enabled",
65 [JTAG_TAP_EVENT_DISABLE
] = "TAP disabled",
68 static int jtag_trst
= 0;
69 static int jtag_srst
= 0;
72 * List all TAPs that have been created.
74 static jtag_tap_t
*__jtag_all_taps
= NULL
;
76 * The number of TAPs in the __jtag_all_taps list, used to track the
77 * assigned chain position to new TAPs
79 static unsigned jtag_num_taps
= 0;
81 static enum reset_types jtag_reset_config
= RESET_NONE
;
82 static tap_state_t cmd_queue_end_state
= TAP_RESET
;
83 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
85 static bool jtag_verify_capture_ir
= true;
86 static int jtag_verify
= 1;
88 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
89 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
90 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
92 typedef struct jtag_event_callback_s
94 jtag_event_handler_t callback
;
96 struct jtag_event_callback_s
* next
;
97 } jtag_event_callback_t
;
99 /* callbacks to inform high-level handlers about JTAG state changes */
100 static jtag_event_callback_t
*jtag_event_callbacks
;
103 static int speed_khz
= 0;
104 /* speed to fallback to when RCLK is requested but not supported */
105 static int rclk_fallback_speed_khz
= 0;
106 static enum {CLOCK_MODE_SPEED
, CLOCK_MODE_KHZ
, CLOCK_MODE_RCLK
} clock_mode
;
107 static int jtag_speed
= 0;
109 static struct jtag_interface_s
*jtag
= NULL
;
112 jtag_interface_t
*jtag_interface
= NULL
;
114 void jtag_set_error(int error
)
116 if ((error
== ERROR_OK
) || (jtag_error
!= ERROR_OK
))
120 int jtag_get_error(void)
124 int jtag_error_clear(void)
126 int temp
= jtag_error
;
127 jtag_error
= ERROR_OK
;
132 jtag_tap_t
*jtag_all_taps(void)
134 return __jtag_all_taps
;
137 unsigned jtag_tap_count(void)
139 return jtag_num_taps
;
142 unsigned jtag_tap_count_enabled(void)
144 jtag_tap_t
*t
= jtag_all_taps();
155 /// Append a new TAP to the chain of all taps.
156 void jtag_tap_add(struct jtag_tap_s
*t
)
158 t
->abs_chain_position
= jtag_num_taps
++;
160 jtag_tap_t
**tap
= &__jtag_all_taps
;
162 tap
= &(*tap
)->next_tap
;
166 /* returns a pointer to the n-th device in the scan chain */
167 static inline jtag_tap_t
*jtag_tap_by_position(unsigned n
)
169 jtag_tap_t
*t
= jtag_all_taps();
177 jtag_tap_t
*jtag_tap_by_string(const char *s
)
179 /* try by name first */
180 jtag_tap_t
*t
= jtag_all_taps();
184 if (0 == strcmp(t
->dotted_name
, s
))
189 /* no tap found by name, so try to parse the name as a number */
191 if (parse_uint(s
, &n
) != ERROR_OK
)
194 /* FIXME remove this numeric fallback code late June 2010, along
195 * with all info in the User's Guide that TAPs have numeric IDs.
196 * Also update "scan_chain" output to not display the numbers.
198 t
= jtag_tap_by_position(n
);
200 LOG_WARNING("Specify TAP '%s' by name, not number %u",
206 jtag_tap_t
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
208 const char *cp
= Jim_GetString(o
, NULL
);
209 jtag_tap_t
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
213 Jim_SetResult_sprintf(interp
, "Tap '%s' could not be found", cp
);
217 jtag_tap_t
* jtag_tap_next_enabled(jtag_tap_t
* p
)
219 p
= p
? p
->next_tap
: jtag_all_taps();
229 const char *jtag_tap_name(const jtag_tap_t
*tap
)
231 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
235 int jtag_register_event_callback(jtag_event_handler_t callback
, void *priv
)
237 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
239 if (callback
== NULL
)
241 return ERROR_INVALID_ARGUMENTS
;
246 while ((*callbacks_p
)->next
)
247 callbacks_p
= &((*callbacks_p
)->next
);
248 callbacks_p
= &((*callbacks_p
)->next
);
251 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
252 (*callbacks_p
)->callback
= callback
;
253 (*callbacks_p
)->priv
= priv
;
254 (*callbacks_p
)->next
= NULL
;
259 int jtag_unregister_event_callback(jtag_event_handler_t callback
, void *priv
)
261 jtag_event_callback_t
**callbacks_p
;
262 jtag_event_callback_t
**next
;
264 if (callback
== NULL
)
266 return ERROR_INVALID_ARGUMENTS
;
269 for (callbacks_p
= &jtag_event_callbacks
;
270 *callbacks_p
!= NULL
;
273 next
= &((*callbacks_p
)->next
);
275 if ((*callbacks_p
)->priv
!= priv
)
278 if ((*callbacks_p
)->callback
== callback
)
281 *callbacks_p
= *next
;
288 int jtag_call_event_callbacks(enum jtag_event event
)
290 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
292 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
296 jtag_event_callback_t
*next
;
298 /* callback may remove itself */
299 next
= callback
->next
;
300 callback
->callback(event
, callback
->priv
);
307 static void jtag_checks(void)
309 assert(jtag_trst
== 0);
312 static void jtag_prelude(tap_state_t state
)
316 assert(state
!= TAP_INVALID
);
318 cmd_queue_cur_state
= state
;
321 void jtag_alloc_in_value32(scan_field_t
*field
)
323 interface_jtag_alloc_in_value32(field
);
326 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
331 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
332 jtag_set_error(retval
);
336 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
338 if (jtag_verify
&& jtag_verify_capture_ir
)
340 /* 8 x 32 bit id's is enough for all invocations */
342 for (int j
= 0; j
< in_num_fields
; j
++)
344 /* if we are to run a verification of the ir scan, we need to get the input back.
345 * We may have to allocate space if the caller didn't ask for the input back.
347 in_fields
[j
].check_value
= in_fields
[j
].tap
->expected
;
348 in_fields
[j
].check_mask
= in_fields
[j
].tap
->expected_mask
;
350 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
353 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
357 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
362 int retval
= interface_jtag_add_plain_ir_scan(
363 in_num_fields
, in_fields
, state
);
364 jtag_set_error(retval
);
367 void jtag_add_callback(jtag_callback1_t f
, jtag_callback_data_t data0
)
369 interface_jtag_add_callback(f
, data0
);
372 void jtag_add_callback4(jtag_callback_t f
, jtag_callback_data_t data0
,
373 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
374 jtag_callback_data_t data3
)
376 interface_jtag_add_callback4(f
, data0
, data1
, data2
, data3
);
379 int jtag_check_value_inner(uint8_t *captured
, uint8_t *in_check_value
, uint8_t *in_check_mask
, int num_bits
);
381 static int jtag_check_value_mask_callback(jtag_callback_data_t data0
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
383 return jtag_check_value_inner((uint8_t *)data0
, (uint8_t *)data1
, (uint8_t *)data2
, (int)data3
);
386 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
387 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
389 for (int i
= 0; i
< in_num_fields
; i
++)
391 struct scan_field_s
*field
= &in_fields
[i
];
392 field
->allocated
= 0;
394 if (field
->check_value
|| field
->in_value
)
396 interface_jtag_add_scan_check_alloc(field
);
400 jtag_add_scan(in_num_fields
, in_fields
, state
);
402 for (int i
= 0; i
< in_num_fields
; i
++)
404 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
406 /* this is synchronous for a minidriver */
407 jtag_add_callback4(jtag_check_value_mask_callback
, (jtag_callback_data_t
)in_fields
[i
].in_value
,
408 (jtag_callback_data_t
)in_fields
[i
].check_value
,
409 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
410 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
412 if (in_fields
[i
].allocated
)
414 free(in_fields
[i
].in_value
);
416 if (in_fields
[i
].modified
)
418 in_fields
[i
].in_value
= NULL
;
423 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
427 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
430 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
435 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
441 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
442 jtag_set_error(retval
);
445 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
451 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
452 jtag_set_error(retval
);
455 void jtag_add_dr_out(jtag_tap_t
* tap
,
456 int num_fields
, const int* num_bits
, const uint32_t* value
,
457 tap_state_t end_state
)
459 assert(end_state
!= TAP_INVALID
);
461 cmd_queue_cur_state
= end_state
;
463 interface_jtag_add_dr_out(tap
,
464 num_fields
, num_bits
, value
,
468 void jtag_add_tlr(void)
470 jtag_prelude(TAP_RESET
);
471 jtag_set_error(interface_jtag_add_tlr());
472 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
475 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
477 tap_state_t cur_state
= cmd_queue_cur_state
;
479 /* the last state has to be a stable state */
480 if (!tap_is_state_stable(path
[num_states
- 1]))
482 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
483 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
487 for (int i
= 0; i
< num_states
; i
++)
489 if (path
[i
] == TAP_RESET
)
491 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
492 jtag_set_error(ERROR_JTAG_STATE_INVALID
);
496 if (tap_state_transition(cur_state
, true) != path
[i
]
497 && tap_state_transition(cur_state
, false) != path
[i
])
499 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
500 tap_state_name(cur_state
), tap_state_name(path
[i
]));
501 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID
);
509 jtag_set_error(interface_jtag_add_pathmove(num_states
, path
));
510 cmd_queue_cur_state
= path
[num_states
- 1];
513 int jtag_add_statemove(tap_state_t goal_state
)
515 tap_state_t cur_state
= cmd_queue_cur_state
;
517 LOG_DEBUG("cur_state=%s goal_state=%s",
518 tap_state_name(cur_state
),
519 tap_state_name(goal_state
));
522 if (goal_state
== cur_state
)
523 ; /* nothing to do */
524 else if (goal_state
== TAP_RESET
)
528 else if (tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
))
530 unsigned tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
531 unsigned tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
532 tap_state_t moves
[8];
533 assert(tms_count
< DIM(moves
));
535 for (unsigned i
= 0; i
< tms_count
; i
++, tms_bits
>>= 1)
537 bool bit
= tms_bits
& 1;
539 cur_state
= tap_state_transition(cur_state
, bit
);
540 moves
[i
] = cur_state
;
543 jtag_add_pathmove(tms_count
, moves
);
545 else if (tap_state_transition(cur_state
, true) == goal_state
546 || tap_state_transition(cur_state
, false) == goal_state
)
548 jtag_add_pathmove(1, &goal_state
);
557 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
560 jtag_set_error(interface_jtag_add_runtest(num_cycles
, state
));
564 void jtag_add_clocks(int num_cycles
)
566 if (!tap_is_state_stable(cmd_queue_cur_state
))
568 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
569 tap_state_name(cmd_queue_cur_state
));
570 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
577 jtag_set_error(interface_jtag_add_clocks(num_cycles
));
581 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
583 int trst_with_tlr
= 0;
585 /* FIX!!! there are *many* different cases here. A better
586 * approach is needed for legal combinations of transitions...
588 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
589 (jtag_reset_config
& RESET_HAS_TRST
)&&
590 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
) == 0))
592 if (((req_tlr_or_trst
&&!jtag_trst
)||
593 (!req_tlr_or_trst
&& jtag_trst
))&&
594 ((req_srst
&&!jtag_srst
)||
595 (!req_srst
&& jtag_srst
)))
597 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
598 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
602 /* Make sure that jtag_reset_config allows the requested reset */
603 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
604 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
606 LOG_ERROR("BUG: requested reset would assert trst");
607 jtag_set_error(ERROR_FAIL
);
611 /* if TRST pulls SRST, we reset with TAP T-L-R */
612 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
617 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
619 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
620 jtag_set_error(ERROR_FAIL
);
626 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
638 jtag_srst
= req_srst
;
640 int retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
641 if (retval
!= ERROR_OK
)
643 jtag_set_error(retval
);
646 jtag_execute_queue();
650 LOG_DEBUG("SRST line asserted");
654 LOG_DEBUG("SRST line released");
655 if (jtag_nsrst_delay
)
656 jtag_add_sleep(jtag_nsrst_delay
* 1000);
661 LOG_DEBUG("JTAG reset with RESET instead of TRST");
662 jtag_set_end_state(TAP_RESET
);
669 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
670 * and inform possible listeners about this
672 LOG_DEBUG("TRST line asserted");
673 tap_set_state(TAP_RESET
);
674 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
678 if (jtag_ntrst_delay
)
679 jtag_add_sleep(jtag_ntrst_delay
* 1000);
683 tap_state_t
jtag_set_end_state(tap_state_t state
)
685 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
687 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
690 if (state
!= TAP_INVALID
)
691 cmd_queue_end_state
= state
;
692 return cmd_queue_end_state
;
695 tap_state_t
jtag_get_end_state(void)
697 return cmd_queue_end_state
;
700 void jtag_add_sleep(uint32_t us
)
702 /// @todo Here, keep_alive() appears to be a layering violation!!!
704 jtag_set_error(interface_jtag_add_sleep(us
));
707 int jtag_check_value_inner(uint8_t *captured
, uint8_t *in_check_value
, uint8_t *in_check_mask
, int num_bits
)
709 int retval
= ERROR_OK
;
711 int compare_failed
= 0;
714 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
716 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
718 if (compare_failed
) {
719 /* An error handler could have caught the failing check
720 * only report a problem when there wasn't a handler, or if the handler
721 * acknowledged the error
724 LOG_WARNING("TAP %s:",
725 jtag_tap_name(field->tap));
729 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
730 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
734 char *in_check_mask_char
;
735 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
736 LOG_WARNING("value captured during scan didn't pass the requested check:");
737 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
738 captured_char
, in_check_value_char
, in_check_mask_char
);
739 free(in_check_mask_char
);
743 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
);
747 free(in_check_value_char
);
749 retval
= ERROR_JTAG_QUEUE_FAILED
;
756 void jtag_check_value_mask(scan_field_t
*field
, uint8_t *value
, uint8_t *mask
)
758 assert(field
->in_value
!= NULL
);
762 /* no checking to do */
766 jtag_execute_queue_noclear();
768 int retval
= jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
769 jtag_set_error(retval
);
774 int default_interface_jtag_execute_queue(void)
778 LOG_ERROR("No JTAG interface configured yet. "
779 "Issue 'init' command in startup scripts "
780 "before communicating with targets.");
784 return jtag
->execute_queue();
787 void jtag_execute_queue_noclear(void)
789 jtag_flush_queue_count
++;
790 jtag_set_error(interface_jtag_execute_queue());
793 int jtag_get_flush_queue_count(void)
795 return jtag_flush_queue_count
;
798 int jtag_execute_queue(void)
800 jtag_execute_queue_noclear();
801 return jtag_error_clear();
804 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
806 jtag_tap_t
*tap
= priv
;
810 if (event
== JTAG_TRST_ASSERTED
)
812 tap
->enabled
= !tap
->disabled_after_reset
;
814 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
821 void jtag_sleep(uint32_t us
)
823 alive_sleep(us
/1000);
826 /// maximum number of JTAG devices expected in the chain
827 #define JTAG_MAX_CHAIN_SIZE 20
829 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
830 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
831 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
833 static int jtag_examine_chain_execute(uint8_t *idcode_buffer
, unsigned num_idcode
)
835 scan_field_t field
= {
837 .num_bits
= num_idcode
* 32,
838 .out_value
= idcode_buffer
,
839 .in_value
= idcode_buffer
,
842 // initialize to the end of chain ID value
843 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
844 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
846 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
847 return jtag_execute_queue();
850 static bool jtag_examine_chain_check(uint8_t *idcodes
, unsigned count
)
852 uint8_t zero_check
= 0x0;
853 uint8_t one_check
= 0xff;
855 for (unsigned i
= 0; i
< count
* 4; i
++)
857 zero_check
|= idcodes
[i
];
858 one_check
&= idcodes
[i
];
861 /* if there wasn't a single non-zero bit or if all bits were one,
862 * the scan is not valid */
863 if (zero_check
== 0x00 || one_check
== 0xff)
865 LOG_ERROR("JTAG communication failure: check connection, "
866 "JTAG interface, target power etc.");
872 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
873 const char *name
, uint32_t idcode
)
875 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
876 "JTAG tap: %s %16.16s: 0x%08x "
877 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
879 (unsigned int)idcode
,
880 (unsigned int)EXTRACT_MFG(idcode
),
881 (unsigned int)EXTRACT_PART(idcode
),
882 (unsigned int)EXTRACT_VER(idcode
));
885 static bool jtag_idcode_is_final(uint32_t idcode
)
887 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
891 * This helper checks that remaining bits in the examined chain data are
892 * all as expected, but a single JTAG device requires only 64 bits to be
893 * read back correctly. This can help identify and diagnose problems
894 * with the JTAG chain earlier, gives more helpful/explicit error messages.
896 static void jtag_examine_chain_end(uint8_t *idcodes
, unsigned count
, unsigned max
)
898 bool triggered
= false;
899 for (; count
< max
- 31; count
+= 32)
901 uint32_t idcode
= buf_get_u32(idcodes
, count
, 32);
902 // do not trigger the warning if the data looks good
903 if (!triggered
&& jtag_idcode_is_final(idcode
))
905 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
906 count
, (unsigned int)idcode
);
911 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
913 if (0 == tap
->expected_ids_cnt
)
915 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
917 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
918 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
923 /* Loop over the expected identification codes and test for a match */
925 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
927 if (tap
->idcode
== tap
->expected_ids
[ii
])
931 /* If none of the expected ids matched, log an error */
932 if (ii
!= tap
->expected_ids_cnt
)
934 LOG_INFO("JTAG Tap/device matched");
937 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
938 tap
->dotted_name
, tap
->idcode
);
939 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
942 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
943 ii
+ 1, tap
->expected_ids_cnt
);
944 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
945 tap
->dotted_name
, tap
->expected_ids
[ii
]);
950 /* Try to examine chain layout according to IEEE 1149.1 §12
952 int jtag_examine_chain(void)
954 uint8_t idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
955 unsigned device_count
= 0;
957 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
959 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
960 return ERROR_JTAG_INIT_FAILED
;
962 /* point at the 1st tap */
963 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
966 LOG_ERROR("JTAG: No taps enabled?");
967 return ERROR_JTAG_INIT_FAILED
;
970 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
972 uint32_t idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
973 if ((idcode
& 1) == 0)
975 /* LSB must not be 0, this indicates a device in bypass */
976 LOG_WARNING("Tap/Device does not have IDCODE");
984 * End of chain (invalid manufacturer ID) some devices, such
985 * as AVR will output all 1's instead of TDI input value at
988 if (jtag_idcode_is_final(idcode
))
990 jtag_examine_chain_end(idcode_buffer
,
991 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
995 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
996 tap
? tap
->dotted_name
: "(not-named)",
1005 tap
->idcode
= idcode
;
1007 // ensure the TAP ID does matches what was expected
1008 if (!jtag_examine_chain_match_tap(tap
))
1009 return ERROR_JTAG_INIT_FAILED
;
1011 tap
= jtag_tap_next_enabled(tap
);
1014 /* see if number of discovered devices matches configuration */
1015 if (device_count
!= jtag_tap_count_enabled())
1017 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
1018 "does not match (enabled) configuration (%i), total taps: %d",
1019 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
1020 LOG_ERROR("check the config file and ensure proper JTAG communication"
1021 " (connections, speed, ...)");
1022 return ERROR_JTAG_INIT_FAILED
;
1028 int jtag_validate_chain(void)
1031 int total_ir_length
= 0;
1032 uint8_t *ir_test
= NULL
;
1037 total_ir_length
= 0;
1039 tap
= jtag_tap_next_enabled(tap
);
1043 total_ir_length
+= tap
->ir_length
;
1046 total_ir_length
+= 2;
1047 ir_test
= malloc(CEIL(total_ir_length
, 8));
1048 buf_set_ones(ir_test
, total_ir_length
);
1051 field
.num_bits
= total_ir_length
;
1052 field
.out_value
= ir_test
;
1053 field
.in_value
= ir_test
;
1056 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1057 jtag_execute_queue();
1063 tap
= jtag_tap_next_enabled(tap
);
1068 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1071 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1072 LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf
, jtag_tap_name(tap
), chain_pos
, val
);
1075 return ERROR_JTAG_INIT_FAILED
;
1077 chain_pos
+= tap
->ir_length
;
1080 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1083 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1084 LOG_ERROR("Could not validate end of JTAG scan chain, IR mismatch, scan returned 0x%s. pos=%d expected 0x3 got %0x", cbuf
, chain_pos
, val
);
1087 return ERROR_JTAG_INIT_FAILED
;
1096 void jtag_tap_init(jtag_tap_t
*tap
)
1098 assert(0 != tap
->ir_length
);
1100 tap
->expected
= malloc(tap
->ir_length
);
1101 tap
->expected_mask
= malloc(tap
->ir_length
);
1102 tap
->cur_instr
= malloc(tap
->ir_length
);
1104 /// @todo cope sanely with ir_length bigger than 32 bits
1105 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1106 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1107 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1109 // place TAP in bypass mode
1111 // register the reset callback for the TAP
1112 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1114 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1115 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1116 tap
->abs_chain_position
, tap
->ir_length
,
1117 (unsigned int)(tap
->ir_capture_value
), (unsigned int)(tap
->ir_capture_mask
));
1121 void jtag_tap_free(jtag_tap_t
*tap
)
1123 jtag_unregister_event_callback(&jtag_reset_callback
, tap
);
1125 /// @todo is anything missing? no memory leaks please
1126 free((void *)tap
->expected_ids
);
1127 free((void *)tap
->chip
);
1128 free((void *)tap
->tapname
);
1129 free((void *)tap
->dotted_name
);
1133 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1138 if (!jtag_interface
)
1140 /* nothing was previously specified by "interface" command */
1141 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1142 return ERROR_JTAG_INVALID_INTERFACE
;
1145 jtag
= jtag_interface
;
1146 if (jtag_interface
->init() != ERROR_OK
)
1149 return ERROR_JTAG_INIT_FAILED
;
1152 int requested_khz
= jtag_get_speed_khz();
1153 int actual_khz
= requested_khz
;
1154 int retval
= jtag_get_speed_readable(&actual_khz
);
1155 if (ERROR_OK
!= retval
)
1156 LOG_INFO("interface specific clock speed value %d", jtag_get_speed());
1157 else if (actual_khz
)
1159 if ((CLOCK_MODE_RCLK
== clock_mode
)
1160 || ((CLOCK_MODE_KHZ
== clock_mode
) && !requested_khz
))
1162 LOG_INFO("RCLK (adaptive clock speed) not supported - fallback to %d kHz"
1166 LOG_INFO("clock speed %d kHz", actual_khz
);
1169 LOG_INFO("RCLK (adaptive clock speed)");
1174 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1179 LOG_DEBUG("Init JTAG chain");
1181 tap
= jtag_tap_next_enabled(NULL
);
1183 LOG_ERROR("There are no enabled taps?");
1184 return ERROR_JTAG_INIT_FAILED
;
1188 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1191 /* examine chain first, as this could discover the real chain layout */
1192 if (jtag_examine_chain() != ERROR_OK
)
1194 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1197 if (jtag_validate_chain() != ERROR_OK
)
1199 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1205 int jtag_interface_quit(void)
1207 if (!jtag
|| !jtag
->quit
)
1210 // close the JTAG interface
1211 int result
= jtag
->quit();
1212 if (ERROR_OK
!= result
)
1213 LOG_ERROR("failed: %d", result
);
1219 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1223 if ((retval
= jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1226 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1228 /* Reset can happen after a power cycle.
1230 * Ideally we would only assert TRST or run RESET before the target reset.
1232 * However w/srst_pulls_trst, trst is asserted together with the target
1233 * reset whether we want it or not.
1235 * NB! Some targets have JTAG circuitry disabled until a
1236 * trst & srst has been asserted.
1238 * NB! here we assume nsrst/ntrst delay are sufficient!
1240 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1243 jtag_add_reset(1, 0); /* RESET or TRST */
1244 if (jtag_reset_config
& RESET_HAS_SRST
)
1246 jtag_add_reset(1, 1);
1247 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
) == 0)
1248 jtag_add_reset(0, 1);
1250 jtag_add_reset(0, 0);
1251 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1254 /* Check that we can communication on the JTAG chain + eventually we want to
1255 * be able to perform enumeration only after OpenOCD has started
1256 * telnet and GDB server
1258 * That would allow users to more easily perform any magic they need to before
1261 return jtag_init_inner(cmd_ctx
);
1264 int jtag_init(struct command_context_s
*cmd_ctx
)
1267 if ((retval
= jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1269 if (jtag_init_inner(cmd_ctx
) == ERROR_OK
)
1273 return jtag_init_reset(cmd_ctx
);
1276 unsigned jtag_get_speed_khz(void)
1281 static int jtag_khz_to_speed(unsigned khz
, int* speed
)
1283 LOG_DEBUG("convert khz to interface specific speed value");
1287 LOG_DEBUG("have interface set up");
1289 int retval
= jtag
->khz(jtag_get_speed_khz(), &speed_div1
);
1290 if (ERROR_OK
!= retval
)
1294 *speed
= speed_div1
;
1299 static int jtag_rclk_to_speed(unsigned fallback_speed_khz
, int* speed
)
1301 int retval
= jtag_khz_to_speed(0, speed
);
1302 if ((ERROR_OK
!= retval
) && fallback_speed_khz
)
1304 LOG_DEBUG("trying fallback speed...");
1305 retval
= jtag_khz_to_speed(fallback_speed_khz
, speed
);
1310 static int jtag_set_speed(int speed
)
1313 /* this command can be called during CONFIG,
1314 * in which case jtag isn't initialized */
1315 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1318 int jtag_config_speed(int speed
)
1320 LOG_DEBUG("handle jtag speed");
1321 clock_mode
= CLOCK_MODE_SPEED
;
1322 return jtag_set_speed(speed
);
1325 int jtag_config_khz(unsigned khz
)
1327 LOG_DEBUG("handle jtag khz");
1328 clock_mode
= CLOCK_MODE_KHZ
;
1330 int retval
= jtag_khz_to_speed(khz
, &speed
);
1331 return (ERROR_OK
!= retval
) ? retval
: jtag_set_speed(speed
);
1334 int jtag_config_rclk(unsigned fallback_speed_khz
)
1336 LOG_DEBUG("handle jtag rclk");
1337 clock_mode
= CLOCK_MODE_RCLK
;
1338 rclk_fallback_speed_khz
= fallback_speed_khz
;
1340 int retval
= jtag_rclk_to_speed(fallback_speed_khz
, &speed
);
1341 return (ERROR_OK
!= retval
) ? retval
: jtag_set_speed(speed
);
1344 int jtag_get_speed(void)
1349 case CLOCK_MODE_SPEED
:
1352 case CLOCK_MODE_KHZ
:
1353 jtag_khz_to_speed(jtag_get_speed_khz(), &speed
);
1355 case CLOCK_MODE_RCLK
:
1356 jtag_rclk_to_speed(rclk_fallback_speed_khz
, &speed
);
1359 LOG_ERROR("BUG: unknown jtag clock mode");
1366 int jtag_get_speed_readable(int *khz
)
1368 return jtag
? jtag
->speed_div(jtag_get_speed(), khz
) : ERROR_OK
;
1371 void jtag_set_verify(bool enable
)
1373 jtag_verify
= enable
;
1376 bool jtag_will_verify()
1381 void jtag_set_verify_capture_ir(bool enable
)
1383 jtag_verify_capture_ir
= enable
;
1386 bool jtag_will_verify_capture_ir()
1388 return jtag_verify_capture_ir
;
1391 int jtag_power_dropout(int *dropout
)
1393 return jtag
->power_dropout(dropout
);
1396 int jtag_srst_asserted(int *srst_asserted
)
1398 return jtag
->srst_asserted(srst_asserted
);
1401 enum reset_types
jtag_get_reset_config(void)
1403 return jtag_reset_config
;
1405 void jtag_set_reset_config(enum reset_types type
)
1407 jtag_reset_config
= type
;
1410 int jtag_get_trst(void)
1414 int jtag_get_srst(void)
1419 void jtag_set_nsrst_delay(unsigned delay
)
1421 jtag_nsrst_delay
= delay
;
1423 unsigned jtag_get_nsrst_delay(void)
1425 return jtag_nsrst_delay
;
1427 void jtag_set_ntrst_delay(unsigned delay
)
1429 jtag_ntrst_delay
= delay
;
1431 unsigned jtag_get_ntrst_delay(void)
1433 return jtag_ntrst_delay
;
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)