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 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
802 void jtag_sleep(u32 us
)
804 alive_sleep(us
/1000);
807 /// maximum number of JTAG devices expected in the chain
808 #define JTAG_MAX_CHAIN_SIZE 20
810 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
811 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
812 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
814 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
816 scan_field_t field
= {
818 .num_bits
= num_idcode
* 32,
819 .out_value
= idcode_buffer
,
820 .in_value
= idcode_buffer
,
823 // initialize to the end of chain ID value
824 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
825 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
827 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
828 return jtag_execute_queue();
831 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
836 for (unsigned i
= 0; i
< count
* 4; i
++)
838 zero_check
|= idcodes
[i
];
839 one_check
&= idcodes
[i
];
842 /* if there wasn't a single non-zero bit or if all bits were one,
843 * the scan is not valid */
844 if (zero_check
== 0x00 || one_check
== 0xff)
846 LOG_ERROR("JTAG communication failure: check connection, "
847 "JTAG interface, target power etc.");
853 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
854 const char *name
, u32 idcode
)
856 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
857 "JTAG tap: %s %16.16s: 0x%08x "
858 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
860 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
863 static bool jtag_idcode_is_final(u32 idcode
)
865 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
869 * This helper checks that remaining bits in the examined chain data are
870 * all as expected, but a single JTAG device requires only 64 bits to be
871 * read back correctly. This can help identify and diagnose problems
872 * with the JTAG chain earlier, gives more helpful/explicit error messages.
874 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
876 bool triggered
= false;
877 for ( ; count
< max
- 31; count
+= 32)
879 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
880 // do not trigger the warning if the data looks good
881 if (!triggered
&& jtag_idcode_is_final(idcode
))
883 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
889 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
891 if (0 == tap
->expected_ids_cnt
)
893 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
895 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
896 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
901 /* Loop over the expected identification codes and test for a match */
903 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
905 if (tap
->idcode
== tap
->expected_ids
[ii
])
909 /* If none of the expected ids matched, log an error */
910 if (ii
!= tap
->expected_ids_cnt
)
912 LOG_INFO("JTAG Tap/device matched");
915 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
916 tap
->dotted_name
, tap
->idcode
);
917 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
920 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
921 ii
+ 1, tap
->expected_ids_cnt
);
922 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
923 tap
->dotted_name
, tap
->expected_ids
[ii
]);
928 /* Try to examine chain layout according to IEEE 1149.1 §12
930 int jtag_examine_chain(void)
932 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
933 unsigned device_count
= 0;
935 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
937 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
938 return ERROR_JTAG_INIT_FAILED
;
940 /* point at the 1st tap */
941 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
944 LOG_ERROR("JTAG: No taps enabled?");
945 return ERROR_JTAG_INIT_FAILED
;
948 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
950 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
951 if ((idcode
& 1) == 0)
953 /* LSB must not be 0, this indicates a device in bypass */
954 LOG_WARNING("Tap/Device does not have IDCODE");
962 * End of chain (invalid manufacturer ID) some devices, such
963 * as AVR will output all 1's instead of TDI input value at
966 if (jtag_idcode_is_final(idcode
))
968 jtag_examine_chain_end(idcode_buffer
,
969 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
973 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
974 tap
? tap
->dotted_name
: "(not-named)",
983 tap
->idcode
= idcode
;
985 // ensure the TAP ID does matches what was expected
986 if (!jtag_examine_chain_match_tap(tap
))
987 return ERROR_JTAG_INIT_FAILED
;
989 tap
= jtag_tap_next_enabled(tap
);
992 /* see if number of discovered devices matches configuration */
993 if (device_count
!= jtag_tap_count_enabled())
995 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
996 "does not match (enabled) configuration (%i), total taps: %d",
997 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
998 LOG_ERROR("check the config file and ensure proper JTAG communication"
999 " (connections, speed, ...)");
1000 return ERROR_JTAG_INIT_FAILED
;
1006 int jtag_validate_chain(void)
1009 int total_ir_length
= 0;
1015 total_ir_length
= 0;
1017 tap
= jtag_tap_next_enabled(tap
);
1021 total_ir_length
+= tap
->ir_length
;
1024 total_ir_length
+= 2;
1025 ir_test
= malloc(CEIL(total_ir_length
, 8));
1026 buf_set_ones(ir_test
, total_ir_length
);
1029 field
.num_bits
= total_ir_length
;
1030 field
.out_value
= ir_test
;
1031 field
.in_value
= ir_test
;
1034 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1035 jtag_execute_queue();
1041 tap
= jtag_tap_next_enabled(tap
);
1046 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1049 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1050 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
);
1053 return ERROR_JTAG_INIT_FAILED
;
1055 chain_pos
+= tap
->ir_length
;
1058 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1061 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1062 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
);
1065 return ERROR_JTAG_INIT_FAILED
;
1074 void jtag_tap_init(jtag_tap_t
*tap
)
1076 assert(0 != tap
->ir_length
);
1078 tap
->expected
= malloc(tap
->ir_length
);
1079 tap
->expected_mask
= malloc(tap
->ir_length
);
1080 tap
->cur_instr
= malloc(tap
->ir_length
);
1082 /// @todo cope sanely with ir_length bigger than 32 bits
1083 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1084 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1085 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1087 // place TAP in bypass mode
1089 // register the reset callback for the TAP
1090 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1092 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1093 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1094 tap
->abs_chain_position
, tap
->ir_length
,
1095 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1099 void jtag_tap_free(jtag_tap_t
*tap
)
1101 jtag_unregister_event_callback(&jtag_reset_callback
, tap
);
1103 /// @todo is anything missing? no memory leaks please
1104 free((void *)tap
->expected_ids
);
1105 free((void *)tap
->chip
);
1106 free((void *)tap
->tapname
);
1107 free((void *)tap
->dotted_name
);
1111 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1116 if (!jtag_interface
)
1118 /* nothing was previously specified by "interface" command */
1119 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1120 return ERROR_JTAG_INVALID_INTERFACE
;
1124 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1128 if (jtag_interface
->init() != ERROR_OK
)
1129 return ERROR_JTAG_INIT_FAILED
;
1131 jtag
= jtag_interface
;
1135 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1140 LOG_DEBUG("Init JTAG chain");
1142 tap
= jtag_tap_next_enabled(NULL
);
1144 LOG_ERROR("There are no enabled taps?");
1145 return ERROR_JTAG_INIT_FAILED
;
1149 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1152 /* examine chain first, as this could discover the real chain layout */
1153 if (jtag_examine_chain() != ERROR_OK
)
1155 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1158 if (jtag_validate_chain() != ERROR_OK
)
1160 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1166 int jtag_interface_quit(void)
1168 if (!jtag
|| !jtag
->quit
)
1171 // close the JTAG interface
1172 int result
= jtag
->quit();
1173 if (ERROR_OK
!= result
)
1174 LOG_ERROR("failed: %d", result
);
1180 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1184 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1187 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1189 /* Reset can happen after a power cycle.
1191 * Ideally we would only assert TRST or run RESET before the target reset.
1193 * However w/srst_pulls_trst, trst is asserted together with the target
1194 * reset whether we want it or not.
1196 * NB! Some targets have JTAG circuitry disabled until a
1197 * trst & srst has been asserted.
1199 * NB! here we assume nsrst/ntrst delay are sufficient!
1201 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1204 jtag_add_reset(1, 0); /* RESET or TRST */
1205 if (jtag_reset_config
& RESET_HAS_SRST
)
1207 jtag_add_reset(1, 1);
1208 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1209 jtag_add_reset(0, 1);
1211 jtag_add_reset(0, 0);
1212 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1215 /* Check that we can communication on the JTAG chain + eventually we want to
1216 * be able to perform enumeration only after OpenOCD has started
1217 * telnet and GDB server
1219 * That would allow users to more easily perform any magic they need to before
1222 return jtag_init_inner(cmd_ctx
);
1225 int jtag_init(struct command_context_s
*cmd_ctx
)
1228 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1230 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1234 return jtag_init_reset(cmd_ctx
);
1237 void jtag_set_speed_khz(unsigned khz
)
1241 unsigned jtag_get_speed_khz(void)
1245 int jtag_config_khz(unsigned khz
)
1247 LOG_DEBUG("handle jtag khz");
1248 jtag_set_speed_khz(khz
);
1253 LOG_DEBUG("have interface set up");
1255 int retval
= jtag
->khz(jtag_get_speed_khz(), &speed_div1
);
1256 if (ERROR_OK
!= retval
)
1258 jtag_set_speed_khz(0);
1261 cur_speed
= speed_div1
;
1263 return jtag_set_speed(cur_speed
);
1266 int jtag_get_speed(void)
1271 int jtag_set_speed(int speed
)
1274 /* this command can be called during CONFIG,
1275 * in which case jtag isn't initialized */
1277 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1280 int jtag_get_speed_readable(int *speed
)
1282 return jtag
? jtag
->speed_div(jtag_get_speed(), speed
) : ERROR_OK
;
1286 void jtag_set_verify(bool enable
)
1288 jtag_verify
= enable
;
1291 bool jtag_will_verify()
1296 void jtag_set_verify_capture_ir(bool enable
)
1298 jtag_verify_capture_ir
= enable
;
1301 bool jtag_will_verify_capture_ir()
1303 return jtag_verify_capture_ir
;
1306 int jtag_power_dropout(int *dropout
)
1308 return jtag
->power_dropout(dropout
);
1311 int jtag_srst_asserted(int *srst_asserted
)
1313 return jtag
->srst_asserted(srst_asserted
);
1316 enum reset_types
jtag_get_reset_config(void)
1318 return jtag_reset_config
;
1320 void jtag_set_reset_config(enum reset_types type
)
1322 jtag_reset_config
= type
;
1325 int jtag_get_trst(void)
1329 int jtag_get_srst(void)
1334 void jtag_set_nsrst_delay(unsigned delay
)
1336 jtag_nsrst_delay
= delay
;
1338 unsigned jtag_get_nsrst_delay(void)
1340 return jtag_nsrst_delay
;
1342 void jtag_set_ntrst_delay(unsigned delay
)
1344 jtag_ntrst_delay
= delay
;
1346 unsigned jtag_get_ntrst_delay(void)
1348 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)