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 char* jtag_event_strings
[] =
63 "JTAG controller reset (RESET or TRST)"
66 static int jtag_trst
= 0;
67 static int jtag_srst
= 0;
70 * List all TAPs that have been created.
72 static jtag_tap_t
*__jtag_all_taps
= NULL
;
74 * The number of TAPs in the __jtag_all_taps list, used to track the
75 * assigned chain position to new TAPs
77 static unsigned jtag_num_taps
= 0;
79 static enum reset_types jtag_reset_config
= RESET_NONE
;
80 static tap_state_t cmd_queue_end_state
= TAP_RESET
;
81 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
83 static bool jtag_verify_capture_ir
= true;
84 static int jtag_verify
= 1;
86 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
87 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
88 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
90 typedef struct jtag_event_callback_s
92 jtag_event_handler_t callback
;
94 struct jtag_event_callback_s
* next
;
95 } jtag_event_callback_t
;
97 /* callbacks to inform high-level handlers about JTAG state changes */
98 static jtag_event_callback_t
*jtag_event_callbacks
;
101 static int speed_khz
= 0;
102 /* flag if the kHz speed was defined */
103 static bool hasKHz
= false;
104 static int jtag_speed
= 0;
106 static struct jtag_interface_s
*jtag
= NULL
;
109 jtag_interface_t
*jtag_interface
= NULL
;
111 void jtag_set_error(int error
)
113 if ((error
== ERROR_OK
) || (jtag_error
!= ERROR_OK
))
117 int jtag_get_error(void)
121 int jtag_error_clear(void)
123 int temp
= jtag_error
;
124 jtag_error
= ERROR_OK
;
129 jtag_tap_t
*jtag_all_taps(void)
131 return __jtag_all_taps
;
134 unsigned jtag_tap_count(void)
136 return jtag_num_taps
;
139 unsigned jtag_tap_count_enabled(void)
141 jtag_tap_t
*t
= jtag_all_taps();
152 /// Append a new TAP to the chain of all taps.
153 void jtag_tap_add(struct jtag_tap_s
*t
)
155 t
->abs_chain_position
= jtag_num_taps
++;
157 jtag_tap_t
**tap
= &__jtag_all_taps
;
159 tap
= &(*tap
)->next_tap
;
163 jtag_tap_t
*jtag_tap_by_string(const char *s
)
165 /* try by name first */
166 jtag_tap_t
*t
= jtag_all_taps();
169 if (0 == strcmp(t
->dotted_name
, s
))
174 /* no tap found by name, so try to parse the name as a number */
176 unsigned n
= strtoul(s
, &cp
, 0);
177 if ((s
== cp
) || (*cp
!= 0))
180 return jtag_tap_by_position(n
);
183 jtag_tap_t
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
185 const char *cp
= Jim_GetString(o
, NULL
);
186 jtag_tap_t
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
190 Jim_SetResult_sprintf(interp
, "Tap '%s' could not be found", cp
);
194 /* returns a pointer to the n-th device in the scan chain */
195 jtag_tap_t
*jtag_tap_by_position(unsigned n
)
197 jtag_tap_t
*t
= jtag_all_taps();
205 const char *jtag_tap_name(const jtag_tap_t
*tap
)
207 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
211 int jtag_register_event_callback(jtag_event_handler_t callback
, void *priv
)
213 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
215 if (callback
== NULL
)
217 return ERROR_INVALID_ARGUMENTS
;
222 while ((*callbacks_p
)->next
)
223 callbacks_p
= &((*callbacks_p
)->next
);
224 callbacks_p
= &((*callbacks_p
)->next
);
227 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
228 (*callbacks_p
)->callback
= callback
;
229 (*callbacks_p
)->priv
= priv
;
230 (*callbacks_p
)->next
= NULL
;
235 int jtag_unregister_event_callback(jtag_event_handler_t callback
)
237 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
239 if (callback
== NULL
)
241 return ERROR_INVALID_ARGUMENTS
;
246 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
247 if ((*callbacks_p
)->callback
== callback
)
250 *callbacks_p
= *next
;
258 int jtag_call_event_callbacks(enum jtag_event event
)
260 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
262 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
266 callback
->callback(event
, callback
->priv
);
267 callback
= callback
->next
;
273 static void jtag_checks(void)
275 assert(jtag_trst
== 0);
278 static void jtag_prelude(tap_state_t state
)
282 assert(state
!=TAP_INVALID
);
284 cmd_queue_cur_state
= state
;
287 void jtag_alloc_in_value32(scan_field_t
*field
)
289 interface_jtag_alloc_in_value32(field
);
292 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
297 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
298 jtag_set_error(retval
);
302 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
304 if (jtag_verify
&&jtag_verify_capture_ir
)
306 /* 8 x 32 bit id's is enough for all invocations */
308 for (int j
= 0; j
< in_num_fields
; j
++)
310 /* if we are to run a verification of the ir scan, we need to get the input back.
311 * We may have to allocate space if the caller didn't ask for the input back.
313 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
314 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
316 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
319 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
323 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
328 int retval
= interface_jtag_add_plain_ir_scan(
329 in_num_fields
, in_fields
, state
);
330 jtag_set_error(retval
);
333 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
335 interface_jtag_add_callback(f
, in
);
338 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
339 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
340 jtag_callback_data_t data3
)
342 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
345 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
347 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
349 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
352 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
353 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
355 for (int i
= 0; i
< in_num_fields
; i
++)
357 struct scan_field_s
*field
= &in_fields
[i
];
358 field
->allocated
= 0;
360 if (field
->check_value
|| field
->in_value
)
362 interface_jtag_add_scan_check_alloc(field
);
366 jtag_add_scan(in_num_fields
, in_fields
, state
);
368 for (int i
= 0; i
< in_num_fields
; i
++)
370 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
372 /* this is synchronous for a minidriver */
373 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
374 (jtag_callback_data_t
)in_fields
[i
].check_value
,
375 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
376 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
378 if (in_fields
[i
].allocated
)
380 free(in_fields
[i
].in_value
);
382 if (in_fields
[i
].modified
)
384 in_fields
[i
].in_value
= NULL
;
389 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
393 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
396 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
401 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
407 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
408 jtag_set_error(retval
);
411 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
417 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
418 jtag_set_error(retval
);
421 void jtag_add_dr_out(jtag_tap_t
* tap
,
422 int num_fields
, const int* num_bits
, const u32
* value
,
423 tap_state_t end_state
)
425 assert(end_state
!= TAP_INVALID
);
427 cmd_queue_cur_state
= end_state
;
429 interface_jtag_add_dr_out(tap
,
430 num_fields
, num_bits
, value
,
434 void jtag_add_tlr(void)
436 jtag_prelude(TAP_RESET
);
437 jtag_set_error(interface_jtag_add_tlr());
438 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
441 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
443 tap_state_t cur_state
= cmd_queue_cur_state
;
445 /* the last state has to be a stable state */
446 if (!tap_is_state_stable(path
[num_states
- 1]))
448 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
449 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
453 for (int i
= 0; i
< num_states
; i
++)
455 if (path
[i
] == TAP_RESET
)
457 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
458 jtag_set_error(ERROR_JTAG_STATE_INVALID
);
462 if ( tap_state_transition(cur_state
, true) != path
[i
]
463 && tap_state_transition(cur_state
, false) != path
[i
])
465 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
466 tap_state_name(cur_state
), tap_state_name(path
[i
]));
467 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID
);
475 jtag_set_error(interface_jtag_add_pathmove(num_states
, path
));
476 cmd_queue_cur_state
= path
[num_states
- 1];
479 int jtag_add_statemove(tap_state_t goal_state
)
481 tap_state_t cur_state
= cmd_queue_cur_state
;
483 LOG_DEBUG( "cur_state=%s goal_state=%s",
484 tap_state_name(cur_state
),
485 tap_state_name(goal_state
) );
488 if (goal_state
==cur_state
)
489 ; /* nothing to do */
490 else if( goal_state
==TAP_RESET
)
494 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
496 unsigned tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
497 unsigned tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
498 tap_state_t moves
[8];
499 assert(tms_count
< DIM(moves
));
501 for (unsigned i
= 0; i
< tms_count
; i
++, tms_bits
>>= 1)
503 bool bit
= tms_bits
& 1;
505 cur_state
= tap_state_transition(cur_state
, bit
);
506 moves
[i
] = cur_state
;
509 jtag_add_pathmove(tms_count
, moves
);
511 else if( tap_state_transition(cur_state
, true) == goal_state
512 || tap_state_transition(cur_state
, false) == goal_state
)
514 jtag_add_pathmove(1, &goal_state
);
523 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
526 jtag_set_error(interface_jtag_add_runtest(num_cycles
, state
));
530 void jtag_add_clocks(int num_cycles
)
532 if (!tap_is_state_stable(cmd_queue_cur_state
))
534 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
535 tap_state_name(cmd_queue_cur_state
));
536 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
543 jtag_set_error(interface_jtag_add_clocks(num_cycles
));
547 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
549 int trst_with_tlr
= 0;
551 /* FIX!!! there are *many* different cases here. A better
552 * approach is needed for legal combinations of transitions...
554 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
555 (jtag_reset_config
& RESET_HAS_TRST
)&&
556 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
558 if (((req_tlr_or_trst
&&!jtag_trst
)||
559 (!req_tlr_or_trst
&&jtag_trst
))&&
560 ((req_srst
&&!jtag_srst
)||
561 (!req_srst
&&jtag_srst
)))
563 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
564 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
568 /* Make sure that jtag_reset_config allows the requested reset */
569 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
570 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
572 LOG_ERROR("BUG: requested reset would assert trst");
573 jtag_set_error(ERROR_FAIL
);
577 /* if TRST pulls SRST, we reset with TAP T-L-R */
578 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
583 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
585 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
586 jtag_set_error(ERROR_FAIL
);
592 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
604 jtag_srst
= req_srst
;
606 int retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
607 if (retval
!= ERROR_OK
)
609 jtag_set_error(retval
);
612 jtag_execute_queue();
616 LOG_DEBUG("SRST line asserted");
620 LOG_DEBUG("SRST line released");
621 if (jtag_nsrst_delay
)
622 jtag_add_sleep(jtag_nsrst_delay
* 1000);
627 LOG_DEBUG("JTAG reset with RESET instead of TRST");
628 jtag_set_end_state(TAP_RESET
);
635 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
636 * and inform possible listeners about this
638 LOG_DEBUG("TRST line asserted");
639 tap_set_state(TAP_RESET
);
640 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
644 if (jtag_ntrst_delay
)
645 jtag_add_sleep(jtag_ntrst_delay
* 1000);
649 tap_state_t
jtag_set_end_state(tap_state_t state
)
651 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
653 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
656 if (state
!=TAP_INVALID
)
657 cmd_queue_end_state
= state
;
658 return cmd_queue_end_state
;
661 tap_state_t
jtag_get_end_state(void)
663 return cmd_queue_end_state
;
666 void jtag_add_sleep(u32 us
)
668 /// @todo Here, keep_alive() appears to be a layering violation!!!
670 jtag_set_error(interface_jtag_add_sleep(us
));
673 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
675 int retval
= ERROR_OK
;
677 int compare_failed
= 0;
680 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
682 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
685 /* An error handler could have caught the failing check
686 * only report a problem when there wasn't a handler, or if the handler
687 * acknowledged the error
690 LOG_WARNING("TAP %s:",
691 jtag_tap_name(field->tap));
695 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
696 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
700 char *in_check_mask_char
;
701 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
702 LOG_WARNING("value captured during scan didn't pass the requested check:");
703 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
704 captured_char
, in_check_value_char
, in_check_mask_char
);
705 free(in_check_mask_char
);
709 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
);
713 free(in_check_value_char
);
715 retval
= ERROR_JTAG_QUEUE_FAILED
;
722 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
724 assert(field
->in_value
!= NULL
);
728 /* no checking to do */
732 jtag_execute_queue_noclear();
734 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
735 jtag_set_error(retval
);
740 int default_interface_jtag_execute_queue(void)
744 LOG_ERROR("No JTAG interface configured yet. "
745 "Issue 'init' command in startup scripts "
746 "before communicating with targets.");
750 return jtag
->execute_queue();
753 void jtag_execute_queue_noclear(void)
755 jtag_flush_queue_count
++;
756 jtag_set_error(interface_jtag_execute_queue());
759 int jtag_get_flush_queue_count(void)
761 return jtag_flush_queue_count
;
764 int jtag_execute_queue(void)
766 jtag_execute_queue_noclear();
767 return jtag_error_clear();
770 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
772 jtag_tap_t
*tap
= priv
;
776 if (event
== JTAG_TRST_ASSERTED
)
778 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
785 void jtag_sleep(u32 us
)
787 alive_sleep(us
/1000);
790 /// maximum number of JTAG devices expected in the chain
791 #define JTAG_MAX_CHAIN_SIZE 20
793 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
794 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
795 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
797 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
799 scan_field_t field
= {
801 .num_bits
= num_idcode
* 32,
802 .out_value
= idcode_buffer
,
803 .in_value
= idcode_buffer
,
806 // initialize to the end of chain ID value
807 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
808 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
810 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
811 return jtag_execute_queue();
814 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
819 for (unsigned i
= 0; i
< count
* 4; i
++)
821 zero_check
|= idcodes
[i
];
822 one_check
&= idcodes
[i
];
825 /* if there wasn't a single non-zero bit or if all bits were one,
826 * the scan is not valid */
827 if (zero_check
== 0x00 || one_check
== 0xff)
829 LOG_ERROR("JTAG communication failure: check connection, "
830 "JTAG interface, target power etc.");
836 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
837 const char *name
, u32 idcode
)
839 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
840 "JTAG tap: %s %16.16s: 0x%08x "
841 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
843 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
846 static bool jtag_idcode_is_final(u32 idcode
)
848 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
852 * This helper checks that remaining bits in the examined chain data are
853 * all as expected, but a single JTAG device requires only 64 bits to be
854 * read back correctly. This can help identify and diagnose problems
855 * with the JTAG chain earlier, gives more helpful/explicit error messages.
857 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
859 bool triggered
= false;
860 for ( ; count
< max
- 31; count
+= 32)
862 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
863 // do not trigger the warning if the data looks good
864 if (!triggered
&& jtag_idcode_is_final(idcode
))
866 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
872 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
874 if (0 == tap
->expected_ids_cnt
)
876 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
878 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
879 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
884 /* Loop over the expected identification codes and test for a match */
886 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
888 if (tap
->idcode
== tap
->expected_ids
[ii
])
892 /* If none of the expected ids matched, log an error */
893 if (ii
!= tap
->expected_ids_cnt
)
895 LOG_INFO("JTAG Tap/device matched");
898 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
899 tap
->dotted_name
, tap
->idcode
);
900 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
903 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
904 ii
+ 1, tap
->expected_ids_cnt
);
905 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
906 tap
->dotted_name
, tap
->expected_ids
[ii
]);
911 /* Try to examine chain layout according to IEEE 1149.1 §12
913 int jtag_examine_chain(void)
915 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
916 unsigned device_count
= 0;
918 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
920 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
921 return ERROR_JTAG_INIT_FAILED
;
923 /* point at the 1st tap */
924 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
927 LOG_ERROR("JTAG: No taps enabled?");
928 return ERROR_JTAG_INIT_FAILED
;
931 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
933 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
934 if ((idcode
& 1) == 0)
936 /* LSB must not be 0, this indicates a device in bypass */
937 LOG_WARNING("Tap/Device does not have IDCODE");
945 * End of chain (invalid manufacturer ID) some devices, such
946 * as AVR will output all 1's instead of TDI input value at
949 if (jtag_idcode_is_final(idcode
))
951 jtag_examine_chain_end(idcode_buffer
,
952 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
956 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
957 tap
? tap
->dotted_name
: "(not-named)",
966 tap
->idcode
= idcode
;
968 // ensure the TAP ID does matches what was expected
969 if (!jtag_examine_chain_match_tap(tap
))
970 return ERROR_JTAG_INIT_FAILED
;
972 tap
= jtag_tap_next_enabled(tap
);
975 /* see if number of discovered devices matches configuration */
976 if (device_count
!= jtag_tap_count_enabled())
978 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
979 "does not match (enabled) configuration (%i), total taps: %d",
980 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
981 LOG_ERROR("check the config file and ensure proper JTAG communication"
982 " (connections, speed, ...)");
983 return ERROR_JTAG_INIT_FAILED
;
989 int jtag_validate_chain(void)
992 int total_ir_length
= 0;
1000 tap
= jtag_tap_next_enabled(tap
);
1004 total_ir_length
+= tap
->ir_length
;
1007 total_ir_length
+= 2;
1008 ir_test
= malloc(CEIL(total_ir_length
, 8));
1009 buf_set_ones(ir_test
, total_ir_length
);
1012 field
.num_bits
= total_ir_length
;
1013 field
.out_value
= ir_test
;
1014 field
.in_value
= ir_test
;
1017 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1018 jtag_execute_queue();
1024 tap
= jtag_tap_next_enabled(tap
);
1029 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1032 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1033 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
);
1036 return ERROR_JTAG_INIT_FAILED
;
1038 chain_pos
+= tap
->ir_length
;
1041 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1044 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1045 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
);
1048 return ERROR_JTAG_INIT_FAILED
;
1057 void jtag_tap_init(jtag_tap_t
*tap
)
1059 assert(0 != tap
->ir_length
);
1061 tap
->expected
= malloc(tap
->ir_length
);
1062 tap
->expected_mask
= malloc(tap
->ir_length
);
1063 tap
->cur_instr
= malloc(tap
->ir_length
);
1065 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1066 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1067 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1069 // place TAP in bypass mode
1071 // register the reset callback for the TAP
1072 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1074 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1075 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1076 tap
->abs_chain_position
, tap
->ir_length
,
1077 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1081 void jtag_tap_free(jtag_tap_t
*tap
)
1083 /// @todo is anything missing? no memory leaks please
1084 free((void *)tap
->expected_ids
);
1085 free((void *)tap
->chip
);
1086 free((void *)tap
->tapname
);
1087 free((void *)tap
->dotted_name
);
1091 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1096 if (!jtag_interface
)
1098 /* nothing was previously specified by "interface" command */
1099 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1100 return ERROR_JTAG_INVALID_INTERFACE
;
1104 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1108 if (jtag_interface
->init() != ERROR_OK
)
1109 return ERROR_JTAG_INIT_FAILED
;
1111 jtag
= jtag_interface
;
1115 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1120 LOG_DEBUG("Init JTAG chain");
1122 tap
= jtag_tap_next_enabled(NULL
);
1124 LOG_ERROR("There are no enabled taps?");
1125 return ERROR_JTAG_INIT_FAILED
;
1129 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1132 /* examine chain first, as this could discover the real chain layout */
1133 if (jtag_examine_chain() != ERROR_OK
)
1135 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1138 if (jtag_validate_chain() != ERROR_OK
)
1140 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1146 int jtag_interface_quit(void)
1148 if (!jtag
|| !jtag
->quit
)
1151 // close the JTAG interface
1152 int result
= jtag
->quit();
1153 if (ERROR_OK
!= result
)
1154 LOG_ERROR("failed: %d", result
);
1160 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1164 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1167 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1169 /* Reset can happen after a power cycle.
1171 * Ideally we would only assert TRST or run RESET before the target reset.
1173 * However w/srst_pulls_trst, trst is asserted together with the target
1174 * reset whether we want it or not.
1176 * NB! Some targets have JTAG circuitry disabled until a
1177 * trst & srst has been asserted.
1179 * NB! here we assume nsrst/ntrst delay are sufficient!
1181 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1184 jtag_add_reset(1, 0); /* RESET or TRST */
1185 if (jtag_reset_config
& RESET_HAS_SRST
)
1187 jtag_add_reset(1, 1);
1188 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1189 jtag_add_reset(0, 1);
1191 jtag_add_reset(0, 0);
1192 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1195 /* Check that we can communication on the JTAG chain + eventually we want to
1196 * be able to perform enumeration only after OpenOCD has started
1197 * telnet and GDB server
1199 * That would allow users to more easily perform any magic they need to before
1202 return jtag_init_inner(cmd_ctx
);
1205 int jtag_init(struct command_context_s
*cmd_ctx
)
1208 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1210 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1214 return jtag_init_reset(cmd_ctx
);
1217 void jtag_set_speed_khz(unsigned khz
)
1221 unsigned jtag_get_speed_khz(void)
1225 int jtag_config_khz(unsigned khz
)
1227 LOG_DEBUG("handle jtag khz");
1228 jtag_set_speed_khz(khz
);
1233 LOG_DEBUG("have interface set up");
1235 int retval
= jtag
->khz(jtag_get_speed_khz(), &speed_div1
);
1236 if (ERROR_OK
!= retval
)
1238 jtag_set_speed_khz(0);
1241 cur_speed
= speed_div1
;
1243 return jtag_set_speed(cur_speed
);
1246 int jtag_get_speed(void)
1251 int jtag_set_speed(int speed
)
1254 /* this command can be called during CONFIG,
1255 * in which case jtag isn't initialized */
1257 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1260 int jtag_get_speed_readable(int *speed
)
1262 return jtag
? jtag
->speed_div(jtag_get_speed(), speed
) : ERROR_OK
;
1266 void jtag_set_verify(bool enable
)
1268 jtag_verify
= enable
;
1271 bool jtag_will_verify()
1276 void jtag_set_verify_capture_ir(bool enable
)
1278 jtag_verify_capture_ir
= enable
;
1281 bool jtag_will_verify_capture_ir()
1283 return jtag_verify_capture_ir
;
1286 int jtag_power_dropout(int *dropout
)
1288 return jtag
->power_dropout(dropout
);
1291 int jtag_srst_asserted(int *srst_asserted
)
1293 return jtag
->srst_asserted(srst_asserted
);
1296 enum reset_types
jtag_get_reset_config(void)
1298 return jtag_reset_config
;
1300 void jtag_set_reset_config(enum reset_types type
)
1302 jtag_reset_config
= type
;
1305 int jtag_get_trst(void)
1309 int jtag_get_srst(void)
1314 void jtag_set_nsrst_delay(unsigned delay
)
1316 jtag_nsrst_delay
= delay
;
1318 unsigned jtag_get_nsrst_delay(void)
1320 return jtag_nsrst_delay
;
1322 void jtag_set_ntrst_delay(unsigned delay
)
1324 jtag_ntrst_delay
= delay
;
1326 unsigned jtag_get_ntrst_delay(void)
1328 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)