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 jtag_tap_t
* jtag_tap_next_enabled(jtag_tap_t
* p
)
207 p
= p
? p
->next_tap
: jtag_all_taps();
217 const char *jtag_tap_name(const jtag_tap_t
*tap
)
219 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
223 int jtag_register_event_callback(jtag_event_handler_t callback
, void *priv
)
225 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
227 if (callback
== NULL
)
229 return ERROR_INVALID_ARGUMENTS
;
234 while ((*callbacks_p
)->next
)
235 callbacks_p
= &((*callbacks_p
)->next
);
236 callbacks_p
= &((*callbacks_p
)->next
);
239 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
240 (*callbacks_p
)->callback
= callback
;
241 (*callbacks_p
)->priv
= priv
;
242 (*callbacks_p
)->next
= NULL
;
247 int jtag_unregister_event_callback(jtag_event_handler_t callback
)
249 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
251 if (callback
== NULL
)
253 return ERROR_INVALID_ARGUMENTS
;
258 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
259 if ((*callbacks_p
)->callback
== callback
)
262 *callbacks_p
= *next
;
270 int jtag_call_event_callbacks(enum jtag_event event
)
272 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
274 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
278 callback
->callback(event
, callback
->priv
);
279 callback
= callback
->next
;
285 static void jtag_checks(void)
287 assert(jtag_trst
== 0);
290 static void jtag_prelude(tap_state_t state
)
294 assert(state
!=TAP_INVALID
);
296 cmd_queue_cur_state
= state
;
299 void jtag_alloc_in_value32(scan_field_t
*field
)
301 interface_jtag_alloc_in_value32(field
);
304 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
309 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
310 jtag_set_error(retval
);
314 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
316 if (jtag_verify
&&jtag_verify_capture_ir
)
318 /* 8 x 32 bit id's is enough for all invocations */
320 for (int j
= 0; j
< in_num_fields
; j
++)
322 /* if we are to run a verification of the ir scan, we need to get the input back.
323 * We may have to allocate space if the caller didn't ask for the input back.
325 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
326 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
328 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
331 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
335 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
340 int retval
= interface_jtag_add_plain_ir_scan(
341 in_num_fields
, in_fields
, state
);
342 jtag_set_error(retval
);
345 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
347 interface_jtag_add_callback(f
, in
);
350 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
351 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
352 jtag_callback_data_t data3
)
354 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
357 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
359 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
361 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
364 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
365 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
367 for (int i
= 0; i
< in_num_fields
; i
++)
369 struct scan_field_s
*field
= &in_fields
[i
];
370 field
->allocated
= 0;
372 if (field
->check_value
|| field
->in_value
)
374 interface_jtag_add_scan_check_alloc(field
);
378 jtag_add_scan(in_num_fields
, in_fields
, state
);
380 for (int i
= 0; i
< in_num_fields
; i
++)
382 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
384 /* this is synchronous for a minidriver */
385 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
386 (jtag_callback_data_t
)in_fields
[i
].check_value
,
387 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
388 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
390 if (in_fields
[i
].allocated
)
392 free(in_fields
[i
].in_value
);
394 if (in_fields
[i
].modified
)
396 in_fields
[i
].in_value
= NULL
;
401 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
405 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
408 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
413 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
419 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
420 jtag_set_error(retval
);
423 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
429 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
430 jtag_set_error(retval
);
433 void jtag_add_dr_out(jtag_tap_t
* tap
,
434 int num_fields
, const int* num_bits
, const u32
* value
,
435 tap_state_t end_state
)
437 assert(end_state
!= TAP_INVALID
);
439 cmd_queue_cur_state
= end_state
;
441 interface_jtag_add_dr_out(tap
,
442 num_fields
, num_bits
, value
,
446 void jtag_add_tlr(void)
448 jtag_prelude(TAP_RESET
);
449 jtag_set_error(interface_jtag_add_tlr());
450 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
453 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
455 tap_state_t cur_state
= cmd_queue_cur_state
;
457 /* the last state has to be a stable state */
458 if (!tap_is_state_stable(path
[num_states
- 1]))
460 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
461 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
465 for (int i
= 0; i
< num_states
; i
++)
467 if (path
[i
] == TAP_RESET
)
469 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
470 jtag_set_error(ERROR_JTAG_STATE_INVALID
);
474 if ( tap_state_transition(cur_state
, true) != path
[i
]
475 && tap_state_transition(cur_state
, false) != path
[i
])
477 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
478 tap_state_name(cur_state
), tap_state_name(path
[i
]));
479 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID
);
487 jtag_set_error(interface_jtag_add_pathmove(num_states
, path
));
488 cmd_queue_cur_state
= path
[num_states
- 1];
491 int jtag_add_statemove(tap_state_t goal_state
)
493 tap_state_t cur_state
= cmd_queue_cur_state
;
495 LOG_DEBUG( "cur_state=%s goal_state=%s",
496 tap_state_name(cur_state
),
497 tap_state_name(goal_state
) );
500 if (goal_state
==cur_state
)
501 ; /* nothing to do */
502 else if( goal_state
==TAP_RESET
)
506 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
508 unsigned tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
509 unsigned tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
510 tap_state_t moves
[8];
511 assert(tms_count
< DIM(moves
));
513 for (unsigned i
= 0; i
< tms_count
; i
++, tms_bits
>>= 1)
515 bool bit
= tms_bits
& 1;
517 cur_state
= tap_state_transition(cur_state
, bit
);
518 moves
[i
] = cur_state
;
521 jtag_add_pathmove(tms_count
, moves
);
523 else if( tap_state_transition(cur_state
, true) == goal_state
524 || tap_state_transition(cur_state
, false) == goal_state
)
526 jtag_add_pathmove(1, &goal_state
);
535 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
538 jtag_set_error(interface_jtag_add_runtest(num_cycles
, state
));
542 void jtag_add_clocks(int num_cycles
)
544 if (!tap_is_state_stable(cmd_queue_cur_state
))
546 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
547 tap_state_name(cmd_queue_cur_state
));
548 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
555 jtag_set_error(interface_jtag_add_clocks(num_cycles
));
559 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
561 int trst_with_tlr
= 0;
563 /* FIX!!! there are *many* different cases here. A better
564 * approach is needed for legal combinations of transitions...
566 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
567 (jtag_reset_config
& RESET_HAS_TRST
)&&
568 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
570 if (((req_tlr_or_trst
&&!jtag_trst
)||
571 (!req_tlr_or_trst
&&jtag_trst
))&&
572 ((req_srst
&&!jtag_srst
)||
573 (!req_srst
&&jtag_srst
)))
575 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
576 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
580 /* Make sure that jtag_reset_config allows the requested reset */
581 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
582 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
584 LOG_ERROR("BUG: requested reset would assert trst");
585 jtag_set_error(ERROR_FAIL
);
589 /* if TRST pulls SRST, we reset with TAP T-L-R */
590 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
595 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
597 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
598 jtag_set_error(ERROR_FAIL
);
604 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
616 jtag_srst
= req_srst
;
618 int retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
619 if (retval
!= ERROR_OK
)
621 jtag_set_error(retval
);
624 jtag_execute_queue();
628 LOG_DEBUG("SRST line asserted");
632 LOG_DEBUG("SRST line released");
633 if (jtag_nsrst_delay
)
634 jtag_add_sleep(jtag_nsrst_delay
* 1000);
639 LOG_DEBUG("JTAG reset with RESET instead of TRST");
640 jtag_set_end_state(TAP_RESET
);
647 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
648 * and inform possible listeners about this
650 LOG_DEBUG("TRST line asserted");
651 tap_set_state(TAP_RESET
);
652 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
656 if (jtag_ntrst_delay
)
657 jtag_add_sleep(jtag_ntrst_delay
* 1000);
661 tap_state_t
jtag_set_end_state(tap_state_t state
)
663 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
665 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
668 if (state
!=TAP_INVALID
)
669 cmd_queue_end_state
= state
;
670 return cmd_queue_end_state
;
673 tap_state_t
jtag_get_end_state(void)
675 return cmd_queue_end_state
;
678 void jtag_add_sleep(u32 us
)
680 /// @todo Here, keep_alive() appears to be a layering violation!!!
682 jtag_set_error(interface_jtag_add_sleep(us
));
685 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
687 int retval
= ERROR_OK
;
689 int compare_failed
= 0;
692 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
694 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
697 /* An error handler could have caught the failing check
698 * only report a problem when there wasn't a handler, or if the handler
699 * acknowledged the error
702 LOG_WARNING("TAP %s:",
703 jtag_tap_name(field->tap));
707 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
708 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
712 char *in_check_mask_char
;
713 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
714 LOG_WARNING("value captured during scan didn't pass the requested check:");
715 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
716 captured_char
, in_check_value_char
, in_check_mask_char
);
717 free(in_check_mask_char
);
721 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
);
725 free(in_check_value_char
);
727 retval
= ERROR_JTAG_QUEUE_FAILED
;
734 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
736 assert(field
->in_value
!= NULL
);
740 /* no checking to do */
744 jtag_execute_queue_noclear();
746 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
747 jtag_set_error(retval
);
752 int default_interface_jtag_execute_queue(void)
756 LOG_ERROR("No JTAG interface configured yet. "
757 "Issue 'init' command in startup scripts "
758 "before communicating with targets.");
762 return jtag
->execute_queue();
765 void jtag_execute_queue_noclear(void)
767 jtag_flush_queue_count
++;
768 jtag_set_error(interface_jtag_execute_queue());
771 int jtag_get_flush_queue_count(void)
773 return jtag_flush_queue_count
;
776 int jtag_execute_queue(void)
778 jtag_execute_queue_noclear();
779 return jtag_error_clear();
782 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
784 jtag_tap_t
*tap
= priv
;
788 if (event
== JTAG_TRST_ASSERTED
)
790 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
797 void jtag_sleep(u32 us
)
799 alive_sleep(us
/1000);
802 /// maximum number of JTAG devices expected in the chain
803 #define JTAG_MAX_CHAIN_SIZE 20
805 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
806 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
807 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
809 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
811 scan_field_t field
= {
813 .num_bits
= num_idcode
* 32,
814 .out_value
= idcode_buffer
,
815 .in_value
= idcode_buffer
,
818 // initialize to the end of chain ID value
819 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
820 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
822 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
823 return jtag_execute_queue();
826 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
831 for (unsigned i
= 0; i
< count
* 4; i
++)
833 zero_check
|= idcodes
[i
];
834 one_check
&= idcodes
[i
];
837 /* if there wasn't a single non-zero bit or if all bits were one,
838 * the scan is not valid */
839 if (zero_check
== 0x00 || one_check
== 0xff)
841 LOG_ERROR("JTAG communication failure: check connection, "
842 "JTAG interface, target power etc.");
848 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
849 const char *name
, u32 idcode
)
851 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
852 "JTAG tap: %s %16.16s: 0x%08x "
853 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
855 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
858 static bool jtag_idcode_is_final(u32 idcode
)
860 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
864 * This helper checks that remaining bits in the examined chain data are
865 * all as expected, but a single JTAG device requires only 64 bits to be
866 * read back correctly. This can help identify and diagnose problems
867 * with the JTAG chain earlier, gives more helpful/explicit error messages.
869 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
871 bool triggered
= false;
872 for ( ; count
< max
- 31; count
+= 32)
874 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
875 // do not trigger the warning if the data looks good
876 if (!triggered
&& jtag_idcode_is_final(idcode
))
878 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
884 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
886 if (0 == tap
->expected_ids_cnt
)
888 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
890 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
891 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
896 /* Loop over the expected identification codes and test for a match */
898 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
900 if (tap
->idcode
== tap
->expected_ids
[ii
])
904 /* If none of the expected ids matched, log an error */
905 if (ii
!= tap
->expected_ids_cnt
)
907 LOG_INFO("JTAG Tap/device matched");
910 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
911 tap
->dotted_name
, tap
->idcode
);
912 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
915 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
916 ii
+ 1, tap
->expected_ids_cnt
);
917 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
918 tap
->dotted_name
, tap
->expected_ids
[ii
]);
923 /* Try to examine chain layout according to IEEE 1149.1 §12
925 int jtag_examine_chain(void)
927 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
928 unsigned device_count
= 0;
930 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
932 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
933 return ERROR_JTAG_INIT_FAILED
;
935 /* point at the 1st tap */
936 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
939 LOG_ERROR("JTAG: No taps enabled?");
940 return ERROR_JTAG_INIT_FAILED
;
943 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
945 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
946 if ((idcode
& 1) == 0)
948 /* LSB must not be 0, this indicates a device in bypass */
949 LOG_WARNING("Tap/Device does not have IDCODE");
957 * End of chain (invalid manufacturer ID) some devices, such
958 * as AVR will output all 1's instead of TDI input value at
961 if (jtag_idcode_is_final(idcode
))
963 jtag_examine_chain_end(idcode_buffer
,
964 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
968 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
969 tap
? tap
->dotted_name
: "(not-named)",
978 tap
->idcode
= idcode
;
980 // ensure the TAP ID does matches what was expected
981 if (!jtag_examine_chain_match_tap(tap
))
982 return ERROR_JTAG_INIT_FAILED
;
984 tap
= jtag_tap_next_enabled(tap
);
987 /* see if number of discovered devices matches configuration */
988 if (device_count
!= jtag_tap_count_enabled())
990 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
991 "does not match (enabled) configuration (%i), total taps: %d",
992 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
993 LOG_ERROR("check the config file and ensure proper JTAG communication"
994 " (connections, speed, ...)");
995 return ERROR_JTAG_INIT_FAILED
;
1001 int jtag_validate_chain(void)
1004 int total_ir_length
= 0;
1010 total_ir_length
= 0;
1012 tap
= jtag_tap_next_enabled(tap
);
1016 total_ir_length
+= tap
->ir_length
;
1019 total_ir_length
+= 2;
1020 ir_test
= malloc(CEIL(total_ir_length
, 8));
1021 buf_set_ones(ir_test
, total_ir_length
);
1024 field
.num_bits
= total_ir_length
;
1025 field
.out_value
= ir_test
;
1026 field
.in_value
= ir_test
;
1029 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1030 jtag_execute_queue();
1036 tap
= jtag_tap_next_enabled(tap
);
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 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
);
1048 return ERROR_JTAG_INIT_FAILED
;
1050 chain_pos
+= tap
->ir_length
;
1053 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1056 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1057 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
);
1060 return ERROR_JTAG_INIT_FAILED
;
1069 void jtag_tap_init(jtag_tap_t
*tap
)
1071 assert(0 != tap
->ir_length
);
1073 tap
->expected
= malloc(tap
->ir_length
);
1074 tap
->expected_mask
= malloc(tap
->ir_length
);
1075 tap
->cur_instr
= malloc(tap
->ir_length
);
1077 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1078 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1079 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1081 // place TAP in bypass mode
1083 // register the reset callback for the TAP
1084 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1086 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1087 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1088 tap
->abs_chain_position
, tap
->ir_length
,
1089 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1093 void jtag_tap_free(jtag_tap_t
*tap
)
1095 /// @todo is anything missing? no memory leaks please
1096 free((void *)tap
->expected_ids
);
1097 free((void *)tap
->chip
);
1098 free((void *)tap
->tapname
);
1099 free((void *)tap
->dotted_name
);
1103 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1108 if (!jtag_interface
)
1110 /* nothing was previously specified by "interface" command */
1111 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1112 return ERROR_JTAG_INVALID_INTERFACE
;
1116 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1120 if (jtag_interface
->init() != ERROR_OK
)
1121 return ERROR_JTAG_INIT_FAILED
;
1123 jtag
= jtag_interface
;
1127 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1132 LOG_DEBUG("Init JTAG chain");
1134 tap
= jtag_tap_next_enabled(NULL
);
1136 LOG_ERROR("There are no enabled taps?");
1137 return ERROR_JTAG_INIT_FAILED
;
1141 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1144 /* examine chain first, as this could discover the real chain layout */
1145 if (jtag_examine_chain() != ERROR_OK
)
1147 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1150 if (jtag_validate_chain() != ERROR_OK
)
1152 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1158 int jtag_interface_quit(void)
1160 if (!jtag
|| !jtag
->quit
)
1163 // close the JTAG interface
1164 int result
= jtag
->quit();
1165 if (ERROR_OK
!= result
)
1166 LOG_ERROR("failed: %d", result
);
1172 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1176 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1179 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1181 /* Reset can happen after a power cycle.
1183 * Ideally we would only assert TRST or run RESET before the target reset.
1185 * However w/srst_pulls_trst, trst is asserted together with the target
1186 * reset whether we want it or not.
1188 * NB! Some targets have JTAG circuitry disabled until a
1189 * trst & srst has been asserted.
1191 * NB! here we assume nsrst/ntrst delay are sufficient!
1193 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1196 jtag_add_reset(1, 0); /* RESET or TRST */
1197 if (jtag_reset_config
& RESET_HAS_SRST
)
1199 jtag_add_reset(1, 1);
1200 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1201 jtag_add_reset(0, 1);
1203 jtag_add_reset(0, 0);
1204 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1207 /* Check that we can communication on the JTAG chain + eventually we want to
1208 * be able to perform enumeration only after OpenOCD has started
1209 * telnet and GDB server
1211 * That would allow users to more easily perform any magic they need to before
1214 return jtag_init_inner(cmd_ctx
);
1217 int jtag_init(struct command_context_s
*cmd_ctx
)
1220 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1222 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1226 return jtag_init_reset(cmd_ctx
);
1229 void jtag_set_speed_khz(unsigned khz
)
1233 unsigned jtag_get_speed_khz(void)
1237 int jtag_config_khz(unsigned khz
)
1239 LOG_DEBUG("handle jtag khz");
1240 jtag_set_speed_khz(khz
);
1245 LOG_DEBUG("have interface set up");
1247 int retval
= jtag
->khz(jtag_get_speed_khz(), &speed_div1
);
1248 if (ERROR_OK
!= retval
)
1250 jtag_set_speed_khz(0);
1253 cur_speed
= speed_div1
;
1255 return jtag_set_speed(cur_speed
);
1258 int jtag_get_speed(void)
1263 int jtag_set_speed(int speed
)
1266 /* this command can be called during CONFIG,
1267 * in which case jtag isn't initialized */
1269 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1272 int jtag_get_speed_readable(int *speed
)
1274 return jtag
? jtag
->speed_div(jtag_get_speed(), speed
) : ERROR_OK
;
1278 void jtag_set_verify(bool enable
)
1280 jtag_verify
= enable
;
1283 bool jtag_will_verify()
1288 void jtag_set_verify_capture_ir(bool enable
)
1290 jtag_verify_capture_ir
= enable
;
1293 bool jtag_will_verify_capture_ir()
1295 return jtag_verify_capture_ir
;
1298 int jtag_power_dropout(int *dropout
)
1300 return jtag
->power_dropout(dropout
);
1303 int jtag_srst_asserted(int *srst_asserted
)
1305 return jtag
->srst_asserted(srst_asserted
);
1308 enum reset_types
jtag_get_reset_config(void)
1310 return jtag_reset_config
;
1312 void jtag_set_reset_config(enum reset_types type
)
1314 jtag_reset_config
= type
;
1317 int jtag_get_trst(void)
1321 int jtag_get_srst(void)
1326 void jtag_set_nsrst_delay(unsigned delay
)
1328 jtag_nsrst_delay
= delay
;
1330 unsigned jtag_get_nsrst_delay(void)
1332 return jtag_nsrst_delay
;
1334 void jtag_set_ntrst_delay(unsigned delay
)
1336 jtag_ntrst_delay
= delay
;
1338 unsigned jtag_get_ntrst_delay(void)
1340 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)