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)",
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 if (parse_uint(s
, &n
) != ERROR_OK
)
179 return jtag_tap_by_position(n
);
182 jtag_tap_t
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
184 const char *cp
= Jim_GetString(o
, NULL
);
185 jtag_tap_t
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
189 Jim_SetResult_sprintf(interp
, "Tap '%s' could not be found", cp
);
193 /* returns a pointer to the n-th device in the scan chain */
194 jtag_tap_t
*jtag_tap_by_position(unsigned n
)
196 jtag_tap_t
*t
= jtag_all_taps();
204 jtag_tap_t
* jtag_tap_next_enabled(jtag_tap_t
* p
)
206 p
= p
? p
->next_tap
: jtag_all_taps();
216 const char *jtag_tap_name(const jtag_tap_t
*tap
)
218 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
222 int jtag_register_event_callback(jtag_event_handler_t callback
, void *priv
)
224 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
226 if (callback
== NULL
)
228 return ERROR_INVALID_ARGUMENTS
;
233 while ((*callbacks_p
)->next
)
234 callbacks_p
= &((*callbacks_p
)->next
);
235 callbacks_p
= &((*callbacks_p
)->next
);
238 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
239 (*callbacks_p
)->callback
= callback
;
240 (*callbacks_p
)->priv
= priv
;
241 (*callbacks_p
)->next
= NULL
;
246 int jtag_unregister_event_callback(jtag_event_handler_t callback
, void *priv
)
248 jtag_event_callback_t
**callbacks_p
;
249 jtag_event_callback_t
**next
;
251 if (callback
== NULL
)
253 return ERROR_INVALID_ARGUMENTS
;
256 for (callbacks_p
= &jtag_event_callbacks
;
257 *callbacks_p
!= NULL
;
260 next
= &((*callbacks_p
)->next
);
262 if ((*callbacks_p
)->priv
!= priv
)
265 if ((*callbacks_p
)->callback
== callback
)
268 *callbacks_p
= *next
;
275 int jtag_call_event_callbacks(enum jtag_event event
)
277 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
279 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
283 callback
->callback(event
, callback
->priv
);
284 callback
= callback
->next
;
290 static void jtag_checks(void)
292 assert(jtag_trst
== 0);
295 static void jtag_prelude(tap_state_t state
)
299 assert(state
!=TAP_INVALID
);
301 cmd_queue_cur_state
= state
;
304 void jtag_alloc_in_value32(scan_field_t
*field
)
306 interface_jtag_alloc_in_value32(field
);
309 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
314 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
315 jtag_set_error(retval
);
319 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
321 if (jtag_verify
&&jtag_verify_capture_ir
)
323 /* 8 x 32 bit id's is enough for all invocations */
325 for (int j
= 0; j
< in_num_fields
; j
++)
327 /* if we are to run a verification of the ir scan, we need to get the input back.
328 * We may have to allocate space if the caller didn't ask for the input back.
330 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
331 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
333 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
336 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
340 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
345 int retval
= interface_jtag_add_plain_ir_scan(
346 in_num_fields
, in_fields
, state
);
347 jtag_set_error(retval
);
350 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
352 interface_jtag_add_callback(f
, in
);
355 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
356 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
357 jtag_callback_data_t data3
)
359 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
362 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
364 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
366 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
369 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
370 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
372 for (int i
= 0; i
< in_num_fields
; i
++)
374 struct scan_field_s
*field
= &in_fields
[i
];
375 field
->allocated
= 0;
377 if (field
->check_value
|| field
->in_value
)
379 interface_jtag_add_scan_check_alloc(field
);
383 jtag_add_scan(in_num_fields
, in_fields
, state
);
385 for (int i
= 0; i
< in_num_fields
; i
++)
387 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
389 /* this is synchronous for a minidriver */
390 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
391 (jtag_callback_data_t
)in_fields
[i
].check_value
,
392 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
393 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
395 if (in_fields
[i
].allocated
)
397 free(in_fields
[i
].in_value
);
399 if (in_fields
[i
].modified
)
401 in_fields
[i
].in_value
= NULL
;
406 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
410 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
413 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
418 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
424 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
425 jtag_set_error(retval
);
428 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
434 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
435 jtag_set_error(retval
);
438 void jtag_add_dr_out(jtag_tap_t
* tap
,
439 int num_fields
, const int* num_bits
, const u32
* value
,
440 tap_state_t end_state
)
442 assert(end_state
!= TAP_INVALID
);
444 cmd_queue_cur_state
= end_state
;
446 interface_jtag_add_dr_out(tap
,
447 num_fields
, num_bits
, value
,
451 void jtag_add_tlr(void)
453 jtag_prelude(TAP_RESET
);
454 jtag_set_error(interface_jtag_add_tlr());
455 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
458 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
460 tap_state_t cur_state
= cmd_queue_cur_state
;
462 /* the last state has to be a stable state */
463 if (!tap_is_state_stable(path
[num_states
- 1]))
465 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
466 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
470 for (int i
= 0; i
< num_states
; i
++)
472 if (path
[i
] == TAP_RESET
)
474 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
475 jtag_set_error(ERROR_JTAG_STATE_INVALID
);
479 if ( tap_state_transition(cur_state
, true) != path
[i
]
480 && tap_state_transition(cur_state
, false) != path
[i
])
482 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
483 tap_state_name(cur_state
), tap_state_name(path
[i
]));
484 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID
);
492 jtag_set_error(interface_jtag_add_pathmove(num_states
, path
));
493 cmd_queue_cur_state
= path
[num_states
- 1];
496 int jtag_add_statemove(tap_state_t goal_state
)
498 tap_state_t cur_state
= cmd_queue_cur_state
;
500 LOG_DEBUG( "cur_state=%s goal_state=%s",
501 tap_state_name(cur_state
),
502 tap_state_name(goal_state
) );
505 if (goal_state
==cur_state
)
506 ; /* nothing to do */
507 else if( goal_state
==TAP_RESET
)
511 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
513 unsigned tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
514 unsigned tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
515 tap_state_t moves
[8];
516 assert(tms_count
< DIM(moves
));
518 for (unsigned i
= 0; i
< tms_count
; i
++, tms_bits
>>= 1)
520 bool bit
= tms_bits
& 1;
522 cur_state
= tap_state_transition(cur_state
, bit
);
523 moves
[i
] = cur_state
;
526 jtag_add_pathmove(tms_count
, moves
);
528 else if( tap_state_transition(cur_state
, true) == goal_state
529 || tap_state_transition(cur_state
, false) == goal_state
)
531 jtag_add_pathmove(1, &goal_state
);
540 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
543 jtag_set_error(interface_jtag_add_runtest(num_cycles
, state
));
547 void jtag_add_clocks(int num_cycles
)
549 if (!tap_is_state_stable(cmd_queue_cur_state
))
551 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
552 tap_state_name(cmd_queue_cur_state
));
553 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
560 jtag_set_error(interface_jtag_add_clocks(num_cycles
));
564 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
566 int trst_with_tlr
= 0;
568 /* FIX!!! there are *many* different cases here. A better
569 * approach is needed for legal combinations of transitions...
571 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
572 (jtag_reset_config
& RESET_HAS_TRST
)&&
573 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
575 if (((req_tlr_or_trst
&&!jtag_trst
)||
576 (!req_tlr_or_trst
&&jtag_trst
))&&
577 ((req_srst
&&!jtag_srst
)||
578 (!req_srst
&&jtag_srst
)))
580 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
581 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
585 /* Make sure that jtag_reset_config allows the requested reset */
586 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
587 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
589 LOG_ERROR("BUG: requested reset would assert trst");
590 jtag_set_error(ERROR_FAIL
);
594 /* if TRST pulls SRST, we reset with TAP T-L-R */
595 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
600 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
602 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
603 jtag_set_error(ERROR_FAIL
);
609 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
621 jtag_srst
= req_srst
;
623 int retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
624 if (retval
!= ERROR_OK
)
626 jtag_set_error(retval
);
629 jtag_execute_queue();
633 LOG_DEBUG("SRST line asserted");
637 LOG_DEBUG("SRST line released");
638 if (jtag_nsrst_delay
)
639 jtag_add_sleep(jtag_nsrst_delay
* 1000);
644 LOG_DEBUG("JTAG reset with RESET instead of TRST");
645 jtag_set_end_state(TAP_RESET
);
652 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
653 * and inform possible listeners about this
655 LOG_DEBUG("TRST line asserted");
656 tap_set_state(TAP_RESET
);
657 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
661 if (jtag_ntrst_delay
)
662 jtag_add_sleep(jtag_ntrst_delay
* 1000);
666 tap_state_t
jtag_set_end_state(tap_state_t state
)
668 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
670 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
673 if (state
!=TAP_INVALID
)
674 cmd_queue_end_state
= state
;
675 return cmd_queue_end_state
;
678 tap_state_t
jtag_get_end_state(void)
680 return cmd_queue_end_state
;
683 void jtag_add_sleep(u32 us
)
685 /// @todo Here, keep_alive() appears to be a layering violation!!!
687 jtag_set_error(interface_jtag_add_sleep(us
));
690 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
692 int retval
= ERROR_OK
;
694 int compare_failed
= 0;
697 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
699 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
702 /* An error handler could have caught the failing check
703 * only report a problem when there wasn't a handler, or if the handler
704 * acknowledged the error
707 LOG_WARNING("TAP %s:",
708 jtag_tap_name(field->tap));
712 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
713 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
717 char *in_check_mask_char
;
718 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
719 LOG_WARNING("value captured during scan didn't pass the requested check:");
720 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
721 captured_char
, in_check_value_char
, in_check_mask_char
);
722 free(in_check_mask_char
);
726 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
);
730 free(in_check_value_char
);
732 retval
= ERROR_JTAG_QUEUE_FAILED
;
739 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
741 assert(field
->in_value
!= NULL
);
745 /* no checking to do */
749 jtag_execute_queue_noclear();
751 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
752 jtag_set_error(retval
);
757 int default_interface_jtag_execute_queue(void)
761 LOG_ERROR("No JTAG interface configured yet. "
762 "Issue 'init' command in startup scripts "
763 "before communicating with targets.");
767 return jtag
->execute_queue();
770 void jtag_execute_queue_noclear(void)
772 jtag_flush_queue_count
++;
773 jtag_set_error(interface_jtag_execute_queue());
776 int jtag_get_flush_queue_count(void)
778 return jtag_flush_queue_count
;
781 int jtag_execute_queue(void)
783 jtag_execute_queue_noclear();
784 return jtag_error_clear();
787 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
789 jtag_tap_t
*tap
= priv
;
793 if (event
== JTAG_TRST_ASSERTED
)
795 tap
->enabled
= !tap
->disabled_after_reset
;
797 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
804 void jtag_sleep(u32 us
)
806 alive_sleep(us
/1000);
809 /// maximum number of JTAG devices expected in the chain
810 #define JTAG_MAX_CHAIN_SIZE 20
812 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
813 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
814 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
816 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
818 scan_field_t field
= {
820 .num_bits
= num_idcode
* 32,
821 .out_value
= idcode_buffer
,
822 .in_value
= idcode_buffer
,
825 // initialize to the end of chain ID value
826 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
827 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
829 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
830 return jtag_execute_queue();
833 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
838 for (unsigned i
= 0; i
< count
* 4; i
++)
840 zero_check
|= idcodes
[i
];
841 one_check
&= idcodes
[i
];
844 /* if there wasn't a single non-zero bit or if all bits were one,
845 * the scan is not valid */
846 if (zero_check
== 0x00 || one_check
== 0xff)
848 LOG_ERROR("JTAG communication failure: check connection, "
849 "JTAG interface, target power etc.");
855 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
856 const char *name
, u32 idcode
)
858 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
859 "JTAG tap: %s %16.16s: 0x%08x "
860 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
862 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
865 static bool jtag_idcode_is_final(u32 idcode
)
867 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
871 * This helper checks that remaining bits in the examined chain data are
872 * all as expected, but a single JTAG device requires only 64 bits to be
873 * read back correctly. This can help identify and diagnose problems
874 * with the JTAG chain earlier, gives more helpful/explicit error messages.
876 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
878 bool triggered
= false;
879 for ( ; count
< max
- 31; count
+= 32)
881 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
882 // do not trigger the warning if the data looks good
883 if (!triggered
&& jtag_idcode_is_final(idcode
))
885 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
891 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
893 if (0 == tap
->expected_ids_cnt
)
895 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
897 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
898 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
903 /* Loop over the expected identification codes and test for a match */
905 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
907 if (tap
->idcode
== tap
->expected_ids
[ii
])
911 /* If none of the expected ids matched, log an error */
912 if (ii
!= tap
->expected_ids_cnt
)
914 LOG_INFO("JTAG Tap/device matched");
917 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
918 tap
->dotted_name
, tap
->idcode
);
919 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
922 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
923 ii
+ 1, tap
->expected_ids_cnt
);
924 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
925 tap
->dotted_name
, tap
->expected_ids
[ii
]);
930 /* Try to examine chain layout according to IEEE 1149.1 §12
932 int jtag_examine_chain(void)
934 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
935 unsigned device_count
= 0;
937 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
939 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
940 return ERROR_JTAG_INIT_FAILED
;
942 /* point at the 1st tap */
943 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
946 LOG_ERROR("JTAG: No taps enabled?");
947 return ERROR_JTAG_INIT_FAILED
;
950 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
952 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
953 if ((idcode
& 1) == 0)
955 /* LSB must not be 0, this indicates a device in bypass */
956 LOG_WARNING("Tap/Device does not have IDCODE");
964 * End of chain (invalid manufacturer ID) some devices, such
965 * as AVR will output all 1's instead of TDI input value at
968 if (jtag_idcode_is_final(idcode
))
970 jtag_examine_chain_end(idcode_buffer
,
971 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
975 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
976 tap
? tap
->dotted_name
: "(not-named)",
985 tap
->idcode
= idcode
;
987 // ensure the TAP ID does matches what was expected
988 if (!jtag_examine_chain_match_tap(tap
))
989 return ERROR_JTAG_INIT_FAILED
;
991 tap
= jtag_tap_next_enabled(tap
);
994 /* see if number of discovered devices matches configuration */
995 if (device_count
!= jtag_tap_count_enabled())
997 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
998 "does not match (enabled) configuration (%i), total taps: %d",
999 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
1000 LOG_ERROR("check the config file and ensure proper JTAG communication"
1001 " (connections, speed, ...)");
1002 return ERROR_JTAG_INIT_FAILED
;
1008 int jtag_validate_chain(void)
1011 int total_ir_length
= 0;
1017 total_ir_length
= 0;
1019 tap
= jtag_tap_next_enabled(tap
);
1023 total_ir_length
+= tap
->ir_length
;
1026 total_ir_length
+= 2;
1027 ir_test
= malloc(CEIL(total_ir_length
, 8));
1028 buf_set_ones(ir_test
, total_ir_length
);
1031 field
.num_bits
= total_ir_length
;
1032 field
.out_value
= ir_test
;
1033 field
.in_value
= ir_test
;
1036 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1037 jtag_execute_queue();
1043 tap
= jtag_tap_next_enabled(tap
);
1048 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1051 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1052 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
);
1055 return ERROR_JTAG_INIT_FAILED
;
1057 chain_pos
+= tap
->ir_length
;
1060 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1063 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1064 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
);
1067 return ERROR_JTAG_INIT_FAILED
;
1076 void jtag_tap_init(jtag_tap_t
*tap
)
1078 assert(0 != tap
->ir_length
);
1080 tap
->expected
= malloc(tap
->ir_length
);
1081 tap
->expected_mask
= malloc(tap
->ir_length
);
1082 tap
->cur_instr
= malloc(tap
->ir_length
);
1084 /// @todo cope sanely with ir_length bigger than 32 bits
1085 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1086 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1087 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1089 // place TAP in bypass mode
1091 // register the reset callback for the TAP
1092 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1094 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1095 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1096 tap
->abs_chain_position
, tap
->ir_length
,
1097 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1101 void jtag_tap_free(jtag_tap_t
*tap
)
1103 jtag_unregister_event_callback(&jtag_reset_callback
, tap
);
1105 /// @todo is anything missing? no memory leaks please
1106 free((void *)tap
->expected_ids
);
1107 free((void *)tap
->chip
);
1108 free((void *)tap
->tapname
);
1109 free((void *)tap
->dotted_name
);
1113 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1118 if (!jtag_interface
)
1120 /* nothing was previously specified by "interface" command */
1121 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1122 return ERROR_JTAG_INVALID_INTERFACE
;
1126 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1130 if (jtag_interface
->init() != ERROR_OK
)
1131 return ERROR_JTAG_INIT_FAILED
;
1133 jtag
= jtag_interface
;
1137 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1142 LOG_DEBUG("Init JTAG chain");
1144 tap
= jtag_tap_next_enabled(NULL
);
1146 LOG_ERROR("There are no enabled taps?");
1147 return ERROR_JTAG_INIT_FAILED
;
1151 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1154 /* examine chain first, as this could discover the real chain layout */
1155 if (jtag_examine_chain() != ERROR_OK
)
1157 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1160 if (jtag_validate_chain() != ERROR_OK
)
1162 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1168 int jtag_interface_quit(void)
1170 if (!jtag
|| !jtag
->quit
)
1173 // close the JTAG interface
1174 int result
= jtag
->quit();
1175 if (ERROR_OK
!= result
)
1176 LOG_ERROR("failed: %d", result
);
1182 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1186 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1189 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1191 /* Reset can happen after a power cycle.
1193 * Ideally we would only assert TRST or run RESET before the target reset.
1195 * However w/srst_pulls_trst, trst is asserted together with the target
1196 * reset whether we want it or not.
1198 * NB! Some targets have JTAG circuitry disabled until a
1199 * trst & srst has been asserted.
1201 * NB! here we assume nsrst/ntrst delay are sufficient!
1203 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1206 jtag_add_reset(1, 0); /* RESET or TRST */
1207 if (jtag_reset_config
& RESET_HAS_SRST
)
1209 jtag_add_reset(1, 1);
1210 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1211 jtag_add_reset(0, 1);
1213 jtag_add_reset(0, 0);
1214 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1217 /* Check that we can communication on the JTAG chain + eventually we want to
1218 * be able to perform enumeration only after OpenOCD has started
1219 * telnet and GDB server
1221 * That would allow users to more easily perform any magic they need to before
1224 return jtag_init_inner(cmd_ctx
);
1227 int jtag_init(struct command_context_s
*cmd_ctx
)
1230 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1232 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1236 return jtag_init_reset(cmd_ctx
);
1239 void jtag_set_speed_khz(unsigned khz
)
1243 unsigned jtag_get_speed_khz(void)
1247 int jtag_config_khz(unsigned khz
)
1249 LOG_DEBUG("handle jtag khz");
1250 jtag_set_speed_khz(khz
);
1255 LOG_DEBUG("have interface set up");
1257 int retval
= jtag
->khz(jtag_get_speed_khz(), &speed_div1
);
1258 if (ERROR_OK
!= retval
)
1260 jtag_set_speed_khz(0);
1263 cur_speed
= speed_div1
;
1265 return jtag_set_speed(cur_speed
);
1268 int jtag_get_speed(void)
1273 int jtag_set_speed(int speed
)
1276 /* this command can be called during CONFIG,
1277 * in which case jtag isn't initialized */
1279 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1282 int jtag_get_speed_readable(int *speed
)
1284 return jtag
? jtag
->speed_div(jtag_get_speed(), speed
) : ERROR_OK
;
1288 void jtag_set_verify(bool enable
)
1290 jtag_verify
= enable
;
1293 bool jtag_will_verify()
1298 void jtag_set_verify_capture_ir(bool enable
)
1300 jtag_verify_capture_ir
= enable
;
1303 bool jtag_will_verify_capture_ir()
1305 return jtag_verify_capture_ir
;
1308 int jtag_power_dropout(int *dropout
)
1310 return jtag
->power_dropout(dropout
);
1313 int jtag_srst_asserted(int *srst_asserted
)
1315 return jtag
->srst_asserted(srst_asserted
);
1318 enum reset_types
jtag_get_reset_config(void)
1320 return jtag_reset_config
;
1322 void jtag_set_reset_config(enum reset_types type
)
1324 jtag_reset_config
= type
;
1327 int jtag_get_trst(void)
1331 int jtag_get_srst(void)
1336 void jtag_set_nsrst_delay(unsigned delay
)
1338 jtag_nsrst_delay
= delay
;
1340 unsigned jtag_get_nsrst_delay(void)
1342 return jtag_nsrst_delay
;
1344 void jtag_set_ntrst_delay(unsigned delay
)
1346 jtag_ntrst_delay
= delay
;
1348 unsigned jtag_get_ntrst_delay(void)
1350 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)