Code Review / openocd.git / blob
? search:


2432516a34898ad99f230c1ed97d7ad418963d5a
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2009 SoftPLC Corporation *
9 * http://softplc.com *
10 * dick@softplc.com *
11 * *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
16 * *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
21 * *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program; if not, write to the *
24 * Free Software Foundation, Inc., *
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
26 ***************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include "replacements.h"
32
33 #include "jtag.h"
34
35 #include "command.h"
36 #include "log.h"
37
38 #include <stdlib.h>
39 #include <string.h>
40 #include <unistd.h>
41 #ifdef HAVE_STRINGS_H
42 #include <strings.h>
43 #endif
44
45
46
47 /* note that this is not marked as static as it must be available from outside jtag.c for those
48 that implement the jtag_xxx() minidriver layer
49 */
50 int jtag_error=ERROR_OK;
51
52 typedef struct cmd_queue_page_s
53 {
54 void *address;
55 size_t used;
56 struct cmd_queue_page_s *next;
57 } cmd_queue_page_t;
58
59 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
60 static cmd_queue_page_t *cmd_queue_pages = NULL;
61
62 char* jtag_event_strings[] =
63 {
64 "JTAG controller reset (RESET or TRST)"
65 };
66
67 const Jim_Nvp nvp_jtag_tap_event[] = {
68 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
69 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
70
71 { .name = NULL, .value = -1 }
72 };
73
74 int jtag_trst = 0;
75 int jtag_srst = 0;
76
77 jtag_command_t *jtag_command_queue = NULL;
78 jtag_command_t **last_comand_pointer = &jtag_command_queue;
79 static jtag_tap_t *jtag_all_taps = NULL;
80
81 enum reset_types jtag_reset_config = RESET_NONE;
82 tap_state_t cmd_queue_end_state = TAP_RESET;
83 tap_state_t cmd_queue_cur_state = TAP_RESET;
84
85 int jtag_verify_capture_ir = 1;
86
87 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
88 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
89 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
90
91 /* maximum number of JTAG devices expected in the chain
92 */
93 #define JTAG_MAX_CHAIN_SIZE 20
94
95 /* callbacks to inform high-level handlers about JTAG state changes */
96 jtag_event_callback_t *jtag_event_callbacks;
97
98 /* speed in kHz*/
99 static int speed_khz = 0;
100 /* flag if the kHz speed was defined */
101 static int hasKHz = 0;
102
103 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
104 */
105
106 #if BUILD_ECOSBOARD == 1
107 extern jtag_interface_t zy1000_interface;
108 #endif
109
110 #if BUILD_PARPORT == 1
111 extern jtag_interface_t parport_interface;
112 #endif
113
114 #if BUILD_DUMMY == 1
115 extern jtag_interface_t dummy_interface;
116 #endif
117
118 #if BUILD_FT2232_FTD2XX == 1
119 extern jtag_interface_t ft2232_interface;
120 #endif
121
122 #if BUILD_FT2232_LIBFTDI == 1
123 extern jtag_interface_t ft2232_interface;
124 #endif
125
126 #if BUILD_AMTJTAGACCEL == 1
127 extern jtag_interface_t amt_jtagaccel_interface;
128 #endif
129
130 #if BUILD_EP93XX == 1
131 extern jtag_interface_t ep93xx_interface;
132 #endif
133
134 #if BUILD_AT91RM9200 == 1
135 extern jtag_interface_t at91rm9200_interface;
136 #endif
137
138 #if BUILD_GW16012 == 1
139 extern jtag_interface_t gw16012_interface;
140 #endif
141
142 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
143 extern jtag_interface_t presto_interface;
144 #endif
145
146 #if BUILD_USBPROG == 1
147 extern jtag_interface_t usbprog_interface;
148 #endif
149
150 #if BUILD_JLINK == 1
151 extern jtag_interface_t jlink_interface;
152 #endif
153
154 #if BUILD_VSLLINK == 1
155 extern jtag_interface_t vsllink_interface;
156 #endif
157
158 #if BUILD_RLINK == 1
159 extern jtag_interface_t rlink_interface;
160 #endif
161
162 #if BUILD_ARMJTAGEW == 1
163 extern jtag_interface_t armjtagew_interface;
164 #endif
165
166 jtag_interface_t *jtag_interfaces[] = {
167 #if BUILD_ECOSBOARD == 1
168 &zy1000_interface,
169 #endif
170 #if BUILD_PARPORT == 1
171 &parport_interface,
172 #endif
173 #if BUILD_DUMMY == 1
174 &dummy_interface,
175 #endif
176 #if BUILD_FT2232_FTD2XX == 1
177 &ft2232_interface,
178 #endif
179 #if BUILD_FT2232_LIBFTDI == 1
180 &ft2232_interface,
181 #endif
182 #if BUILD_AMTJTAGACCEL == 1
183 &amt_jtagaccel_interface,
184 #endif
185 #if BUILD_EP93XX == 1
186 &ep93xx_interface,
187 #endif
188 #if BUILD_AT91RM9200 == 1
189 &at91rm9200_interface,
190 #endif
191 #if BUILD_GW16012 == 1
192 &gw16012_interface,
193 #endif
194 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
195 &presto_interface,
196 #endif
197 #if BUILD_USBPROG == 1
198 &usbprog_interface,
199 #endif
200 #if BUILD_JLINK == 1
201 &jlink_interface,
202 #endif
203 #if BUILD_VSLLINK == 1
204 &vsllink_interface,
205 #endif
206 #if BUILD_RLINK == 1
207 &rlink_interface,
208 #endif
209 #if BUILD_ARMJTAGEW == 1
210 &armjtagew_interface,
211 #endif
212 NULL,
213 };
214
215 jtag_interface_t *jtag = NULL;
216
217 /* configuration */
218 static jtag_interface_t *jtag_interface = NULL;
219 int jtag_speed = 0;
220
221 /* forward declarations */
222 //void jtag_add_pathmove(int num_states, tap_state_t *path);
223 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
224 //void jtag_add_end_state(tap_state_t endstate);
225 //void jtag_add_sleep(u32 us);
226 //int jtag_execute_queue(void);
227 static tap_state_t tap_state_by_name(const char *name);
228
229 /* jtag commands */
230 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
231 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
232 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
233 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
234 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
235 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237
238 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239
240 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
241 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
242 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
243 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
244 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
245
246 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
247
248 jtag_tap_t *jtag_AllTaps(void)
249 {
250 return jtag_all_taps;
251 };
252
253 int jtag_NumTotalTaps(void)
254 {
255 jtag_tap_t *t;
256 int n;
257
258 n = 0;
259 t = jtag_AllTaps();
260 while(t){
261 n++;
262 t = t->next_tap;
263 }
264 return n;
265 }
266
267 int jtag_NumEnabledTaps(void)
268 {
269 jtag_tap_t *t;
270 int n;
271
272 n = 0;
273 t = jtag_AllTaps();
274 while(t){
275 if( t->enabled ){
276 n++;
277 }
278 t = t->next_tap;
279 }
280 return n;
281 }
282
283 jtag_tap_t *jtag_TapByString( const char *s )
284 {
285 jtag_tap_t *t;
286 char *cp;
287
288 t = jtag_AllTaps();
289 /* try name first */
290 while(t){
291 if( 0 == strcmp( t->dotted_name, s ) ){
292 break;
293 } else {
294 t = t->next_tap;
295 }
296 }
297 /* backup plan is by number */
298 if( t == NULL ){
299 /* ok - is "s" a number? */
300 int n;
301 n = strtol( s, &cp, 0 );
302 if( (s != cp) && (*cp == 0) ){
303 /* Then it is... */
304 t = jtag_TapByAbsPosition(n);
305 }
306 }
307 return t;
308 }
309
310 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
311 {
312 jtag_tap_t *t;
313 const char *cp;
314
315 cp = Jim_GetString( o, NULL );
316 if(cp == NULL){
317 cp = "(unknown)";
318 t = NULL;
319 } else {
320 t = jtag_TapByString( cp );
321 }
322 if( t == NULL ){
323 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
324 }
325 return t;
326 }
327
328 /* returns a pointer to the n-th device in the scan chain */
329 jtag_tap_t * jtag_TapByAbsPosition( int n )
330 {
331 int orig_n;
332 jtag_tap_t *t;
333
334 orig_n = n;
335 t = jtag_AllTaps();
336
337 while( t && (n > 0)) {
338 n--;
339 t = t->next_tap;
340 }
341 return t;
342 }
343
344 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
345 {
346 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
347
348 if (callback == NULL)
349 {
350 return ERROR_INVALID_ARGUMENTS;
351 }
352
353 if (*callbacks_p)
354 {
355 while ((*callbacks_p)->next)
356 callbacks_p = &((*callbacks_p)->next);
357 callbacks_p = &((*callbacks_p)->next);
358 }
359
360 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
361 (*callbacks_p)->callback = callback;
362 (*callbacks_p)->priv = priv;
363 (*callbacks_p)->next = NULL;
364
365 return ERROR_OK;
366 }
367
368 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
369 {
370 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
371
372 if (callback == NULL)
373 {
374 return ERROR_INVALID_ARGUMENTS;
375 }
376
377 while (*callbacks_p)
378 {
379 jtag_event_callback_t **next = &((*callbacks_p)->next);
380 if ((*callbacks_p)->callback == callback)
381 {
382 free(*callbacks_p);
383 *callbacks_p = *next;
384 }
385 callbacks_p = next;
386 }
387
388 return ERROR_OK;
389 }
390
391 int jtag_call_event_callbacks(enum jtag_event event)
392 {
393 jtag_event_callback_t *callback = jtag_event_callbacks;
394
395 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
396
397 while (callback)
398 {
399 callback->callback(event, callback->priv);
400 callback = callback->next;
401 }
402
403 return ERROR_OK;
404 }
405
406 /* returns a pointer to the pointer of the last command in queue
407 * this may be a pointer to the root pointer (jtag_command_queue)
408 * or to the next member of the last but one command
409 */
410 jtag_command_t** jtag_get_last_command_p(void)
411 {
412 /* jtag_command_t *cmd = jtag_command_queue;
413
414 if (cmd)
415 while (cmd->next)
416 cmd = cmd->next;
417 else
418 return &jtag_command_queue;
419
420 return &cmd->next;*/
421
422 return last_comand_pointer;
423 }
424
425 void* cmd_queue_alloc(size_t size)
426 {
427 cmd_queue_page_t **p_page = &cmd_queue_pages;
428 int offset;
429 u8 *t;
430
431 /*
432 * WARNING:
433 * We align/round the *SIZE* per below
434 * so that all pointers returned by
435 * this function are reasonably well
436 * aligned.
437 *
438 * If we did not, then an "odd-length" request would cause the
439 * *next* allocation to be at an *odd* address, and because
440 * this function has the same type of api as malloc() - we
441 * must also return pointers that have the same type of
442 * alignment.
443 *
444 * What I do not/have is a reasonable portable means
445 * to align by...
446 *
447 * The solution here, is based on these suggestions.
448 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
449 *
450 */
451 union worse_case_align {
452 int i;
453 long l;
454 float f;
455 void *v;
456 };
457 #define ALIGN_SIZE (sizeof(union worse_case_align))
458
459 /* The alignment process. */
460 size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
461 /* Done... */
462
463 if (*p_page)
464 {
465 while ((*p_page)->next)
466 p_page = &((*p_page)->next);
467 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
468 p_page = &((*p_page)->next);
469 }
470
471 if (!*p_page)
472 {
473 *p_page = malloc(sizeof(cmd_queue_page_t));
474 (*p_page)->used = 0;
475 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
476 (*p_page)->next = NULL;
477 }
478
479 offset = (*p_page)->used;
480 (*p_page)->used += size;
481
482 t=(u8 *)((*p_page)->address);
483 return t + offset;
484 }
485
486 void cmd_queue_free(void)
487 {
488 cmd_queue_page_t *page = cmd_queue_pages;
489
490 while (page)
491 {
492 cmd_queue_page_t *last = page;
493 free(page->address);
494 page = page->next;
495 free(last);
496 }
497
498 cmd_queue_pages = NULL;
499 }
500
501 static void jtag_prelude1(void)
502 {
503 if (jtag_trst == 1)
504 {
505 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
506 jtag_error=ERROR_JTAG_TRST_ASSERTED;
507 return;
508 }
509
510 if (cmd_queue_end_state == TAP_RESET)
511 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
512 }
513
514 static void jtag_prelude(tap_state_t state)
515 {
516 jtag_prelude1();
517
518 if (state != TAP_INVALID)
519 jtag_add_end_state(state);
520
521 cmd_queue_cur_state = cmd_queue_end_state;
522 }
523
524 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
525 {
526 int retval;
527
528 jtag_prelude(state);
529
530 retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
531 if (retval!=ERROR_OK)
532 jtag_error=retval;
533 }
534
535 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
536 {
537 jtag_command_t **last_cmd;
538 jtag_tap_t *tap;
539 int j;
540 int x;
541 int nth_tap;
542 int scan_size = 0;
543
544 last_cmd = jtag_get_last_command_p();
545
546 /* allocate memory for a new list member */
547 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
548 (*last_cmd)->next = NULL;
549 last_comand_pointer = &((*last_cmd)->next);
550 (*last_cmd)->type = JTAG_SCAN;
551
552 /* allocate memory for ir scan command */
553 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
554 (*last_cmd)->cmd.scan->ir_scan = 1;
555 x = jtag_NumEnabledTaps();
556 (*last_cmd)->cmd.scan->num_fields = x; /* one field per device */
557 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x * sizeof(scan_field_t));
558 (*last_cmd)->cmd.scan->end_state = state;
559
560 nth_tap = -1;
561 tap = NULL;
562 for(;;){
563 int found = 0;
564
565 /* do this here so it is not forgotten */
566 tap = jtag_NextEnabledTap(tap);
567 if( tap == NULL ){
568 break;
569 }
570 nth_tap++;
571 scan_size = tap->ir_length;
572 (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
573 (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
574 (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
575 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL; /* disable verification by default */
576
577 /* search the list */
578 for (j = 0; j < num_fields; j++)
579 {
580 if (tap == fields[j].tap)
581 {
582 found = 1;
583 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
584
585 if (jtag_verify_capture_ir)
586 {
587 if (fields[j].in_handler==NULL)
588 {
589 jtag_set_check_value((*last_cmd)->cmd.scan->fields+nth_tap, tap->expected, tap->expected_mask, NULL);
590 } else
591 {
592 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = fields[j].in_handler;
593 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler_priv = fields[j].in_handler_priv;
594 (*last_cmd)->cmd.scan->fields[nth_tap].in_check_value = tap->expected;
595 (*last_cmd)->cmd.scan->fields[nth_tap].in_check_mask = tap->expected_mask;
596 }
597 }
598
599 tap->bypass = 0;
600 break;
601 }
602 }
603
604 if (!found)
605 {
606 /* if a tap isn't listed, set it to BYPASS */
607 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
608 tap->bypass = 1;
609 }
610
611 /* update device information */
612 buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
613 }
614
615 return ERROR_OK;
616 }
617
618 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
619 {
620 int retval;
621
622 jtag_prelude(state);
623
624 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
625 if (retval!=ERROR_OK)
626 jtag_error=retval;
627 }
628
629 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
630 {
631 int i;
632 jtag_command_t **last_cmd;
633
634 last_cmd = jtag_get_last_command_p();
635
636 /* allocate memory for a new list member */
637 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
638 (*last_cmd)->next = NULL;
639 last_comand_pointer = &((*last_cmd)->next);
640 (*last_cmd)->type = JTAG_SCAN;
641
642 /* allocate memory for ir scan command */
643 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
644 (*last_cmd)->cmd.scan->ir_scan = 1;
645 (*last_cmd)->cmd.scan->num_fields = num_fields;
646 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
647 (*last_cmd)->cmd.scan->end_state = state;
648
649 for( i = 0 ; i < num_fields ; i++ ){
650 int num_bits = fields[i].num_bits;
651 int num_bytes = CEIL(fields[i].num_bits, 8);
652 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
653 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
654 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
655 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
656 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
657 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
658 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
659 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
660 }
661 return ERROR_OK;
662 }
663
664 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
665 {
666 int retval;
667
668 jtag_prelude(state);
669
670 retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
671 if (retval!=ERROR_OK)
672 jtag_error=retval;
673 }
674
675 void jtag_add_dr_scan_now(int num_fields, scan_field_t *fields, tap_state_t state)
676 {
677 jtag_add_dr_scan(num_fields, fields, state);
678 jtag_execute_queue_noclear();
679 }
680
681 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
682 {
683 int j;
684 int nth_tap;
685 int bypass_devices = 0;
686 int field_count = 0;
687 int scan_size;
688
689 jtag_command_t **last_cmd = jtag_get_last_command_p();
690 jtag_tap_t *tap;
691
692 /* count devices in bypass */
693 tap = NULL;
694 bypass_devices = 0;
695 for(;;){
696 tap = jtag_NextEnabledTap(tap);
697 if( tap == NULL ){
698 break;
699 }
700 if( tap->bypass ){
701 bypass_devices++;
702 }
703 }
704
705 /* allocate memory for a new list member */
706 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
707 last_comand_pointer = &((*last_cmd)->next);
708 (*last_cmd)->next = NULL;
709 (*last_cmd)->type = JTAG_SCAN;
710
711 /* allocate memory for dr scan command */
712 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
713 (*last_cmd)->cmd.scan->ir_scan = 0;
714 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
715 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
716 (*last_cmd)->cmd.scan->end_state = state;
717
718 tap = NULL;
719 nth_tap = -1;
720 for(;;){
721 nth_tap++;
722 tap = jtag_NextEnabledTap(tap);
723 if( tap == NULL ){
724 break;
725 }
726 int found = 0;
727 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
728
729 for (j = 0; j < num_fields; j++)
730 {
731 if (tap == fields[j].tap)
732 {
733 found = 1;
734 scan_size = fields[j].num_bits;
735 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
736 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
737 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
738 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
739 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
740 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
741 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
742 }
743 }
744 if (!found)
745 {
746 #ifdef _DEBUG_JTAG_IO_
747 /* if a device isn't listed, the BYPASS register should be selected */
748 if (! tap->bypass)
749 {
750 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
751 exit(-1);
752 }
753 #endif
754 /* program the scan field to 1 bit length, and ignore it's value */
755 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
756 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
757 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
758 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
759 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
760 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
761 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
762 }
763 else
764 {
765 #ifdef _DEBUG_JTAG_IO_
766 /* if a device is listed, the BYPASS register must not be selected */
767 if (tap->bypass)
768 {
769 LOG_ERROR("BUG: scan data for a device in BYPASS");
770 exit(-1);
771 }
772 #endif
773 }
774 }
775 return ERROR_OK;
776 }
777
778 void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
779 int num_fields,
780 const int *num_bits,
781 const u32 *value,
782 tap_state_t end_state)
783 {
784 int nth_tap;
785 int field_count = 0;
786 int scan_size;
787 int bypass_devices = 0;
788
789 jtag_command_t **last_cmd = jtag_get_last_command_p();
790 jtag_tap_t *tap;
791
792 /* count devices in bypass */
793 tap = NULL;
794 bypass_devices = 0;
795 for(;;){
796 tap = jtag_NextEnabledTap(tap);
797 if( tap == NULL ){
798 break;
799 }
800 if( tap->bypass ){
801 bypass_devices++;
802 }
803 }
804
805 /* allocate memory for a new list member */
806 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
807 last_comand_pointer = &((*last_cmd)->next);
808 (*last_cmd)->next = NULL;
809 (*last_cmd)->type = JTAG_SCAN;
810
811 /* allocate memory for dr scan command */
812 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
813 (*last_cmd)->cmd.scan->ir_scan = 0;
814 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
815 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
816 (*last_cmd)->cmd.scan->end_state = end_state;
817
818 tap = NULL;
819 nth_tap = -1;
820 for(;;){
821 tap = jtag_NextEnabledTap(tap);
822 if( tap == NULL ){
823 break;
824 }
825 nth_tap++;
826 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
827
828 if (tap == target_tap)
829 {
830 int j;
831 #ifdef _DEBUG_JTAG_IO_
832 /* if a device is listed, the BYPASS register must not be selected */
833 if (tap->bypass)
834 {
835 LOG_ERROR("BUG: scan data for a device in BYPASS");
836 exit(-1);
837 }
838 #endif
839 for (j = 0; j < num_fields; j++)
840 {
841 u8 out_value[4];
842 scan_size = num_bits[j];
843 buf_set_u32(out_value, 0, scan_size, value[j]);
844 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
845 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
846 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
847 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
848 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
849 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
850 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
851 }
852 } else
853 {
854 #ifdef _DEBUG_JTAG_IO_
855 /* if a device isn't listed, the BYPASS register should be selected */
856 if (! tap->bypass)
857 {
858 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
859 exit(-1);
860 }
861 #endif
862 /* program the scan field to 1 bit length, and ignore it's value */
863 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
864 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
865 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
866 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
867 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
868 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
869 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
870 }
871 }
872 }
873
874 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
875 {
876 int retval;
877
878 jtag_prelude(state);
879
880 retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
881 if (retval!=ERROR_OK)
882 jtag_error=retval;
883 }
884
885 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
886 {
887 int i;
888 jtag_command_t **last_cmd = jtag_get_last_command_p();
889
890 /* allocate memory for a new list member */
891 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
892 last_comand_pointer = &((*last_cmd)->next);
893 (*last_cmd)->next = NULL;
894 (*last_cmd)->type = JTAG_SCAN;
895
896 /* allocate memory for scan command */
897 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
898 (*last_cmd)->cmd.scan->ir_scan = 0;
899 (*last_cmd)->cmd.scan->num_fields = num_fields;
900 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
901 (*last_cmd)->cmd.scan->end_state = state;
902
903 for (i = 0; i < num_fields; i++)
904 {
905 int num_bits = fields[i].num_bits;
906 int num_bytes = CEIL(fields[i].num_bits, 8);
907 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
908 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
909 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
910 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
911 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
912 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
913 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
914 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
915 }
916
917 return ERROR_OK;
918 }
919
920 void jtag_add_tlr(void)
921 {
922 jtag_prelude(TAP_RESET);
923
924 int retval;
925 retval=interface_jtag_add_tlr();
926 if (retval!=ERROR_OK)
927 jtag_error=retval;
928 }
929
930 int MINIDRIVER(interface_jtag_add_tlr)(void)
931 {
932 tap_state_t state = TAP_RESET;
933 jtag_command_t **last_cmd = jtag_get_last_command_p();
934
935 /* allocate memory for a new list member */
936 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
937 last_comand_pointer = &((*last_cmd)->next);
938 (*last_cmd)->next = NULL;
939 (*last_cmd)->type = JTAG_STATEMOVE;
940
941 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
942 (*last_cmd)->cmd.statemove->end_state = state;
943
944 return ERROR_OK;
945 }
946
947 void jtag_add_pathmove(int num_states, tap_state_t *path)
948 {
949 tap_state_t cur_state = cmd_queue_cur_state;
950 int i;
951 int retval;
952
953 /* the last state has to be a stable state */
954 if (!tap_is_state_stable(path[num_states - 1]))
955 {
956 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
957 exit(-1);
958 }
959
960 for (i=0; i<num_states; i++)
961 {
962 if (path[i] == TAP_RESET)
963 {
964 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
965 exit(-1);
966 }
967
968 if ( tap_state_transition(cur_state, true) != path[i]
969 && tap_state_transition(cur_state, false) != path[i])
970 {
971 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
972 exit(-1);
973 }
974 cur_state = path[i];
975 }
976
977 jtag_prelude1();
978
979 retval = interface_jtag_add_pathmove(num_states, path);
980 cmd_queue_cur_state = path[num_states - 1];
981 if (retval!=ERROR_OK)
982 jtag_error=retval;
983 }
984
985 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path)
986 {
987 jtag_command_t **last_cmd = jtag_get_last_command_p();
988 int i;
989
990 /* allocate memory for a new list member */
991 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
992 last_comand_pointer = &((*last_cmd)->next);
993 (*last_cmd)->next = NULL;
994 (*last_cmd)->type = JTAG_PATHMOVE;
995
996 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
997 (*last_cmd)->cmd.pathmove->num_states = num_states;
998 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
999
1000 for (i = 0; i < num_states; i++)
1001 (*last_cmd)->cmd.pathmove->path[i] = path[i];
1002
1003 return ERROR_OK;
1004 }
1005
1006 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
1007 {
1008 jtag_command_t **last_cmd = jtag_get_last_command_p();
1009
1010 /* allocate memory for a new list member */
1011 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1012 (*last_cmd)->next = NULL;
1013 last_comand_pointer = &((*last_cmd)->next);
1014 (*last_cmd)->type = JTAG_RUNTEST;
1015
1016 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1017 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
1018 (*last_cmd)->cmd.runtest->end_state = state;
1019
1020 return ERROR_OK;
1021 }
1022
1023 void jtag_add_runtest(int num_cycles, tap_state_t state)
1024 {
1025 int retval;
1026
1027 jtag_prelude(state);
1028
1029 /* executed by sw or hw fifo */
1030 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1031 if (retval!=ERROR_OK)
1032 jtag_error=retval;
1033 }
1034
1035
1036 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1037 {
1038 jtag_command_t **last_cmd = jtag_get_last_command_p();
1039
1040 /* allocate memory for a new list member */
1041 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1042 (*last_cmd)->next = NULL;
1043 last_comand_pointer = &((*last_cmd)->next);
1044 (*last_cmd)->type = JTAG_STABLECLOCKS;
1045
1046 (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1047 (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles;
1048 return ERROR_OK;
1049 }
1050
1051 void jtag_add_clocks( int num_cycles )
1052 {
1053 int retval;
1054
1055 if( !tap_is_state_stable(cmd_queue_cur_state) )
1056 {
1057 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1058 tap_state_name(cmd_queue_cur_state) );
1059 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1060 return;
1061 }
1062
1063 if( num_cycles > 0 )
1064 {
1065 jtag_prelude1();
1066
1067 retval = interface_jtag_add_clocks(num_cycles);
1068 if (retval != ERROR_OK)
1069 jtag_error=retval;
1070 }
1071 }
1072
1073 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1074 {
1075 int trst_with_tlr = 0;
1076 int retval;
1077
1078 /* FIX!!! there are *many* different cases here. A better
1079 * approach is needed for legal combinations of transitions...
1080 */
1081 if ((jtag_reset_config & RESET_HAS_SRST)&&
1082 (jtag_reset_config & RESET_HAS_TRST)&&
1083 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1084 {
1085 if (((req_tlr_or_trst&&!jtag_trst)||
1086 (!req_tlr_or_trst&&jtag_trst))&&
1087 ((req_srst&&!jtag_srst)||
1088 (!req_srst&&jtag_srst)))
1089 {
1090 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1091 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1092 }
1093 }
1094
1095 /* Make sure that jtag_reset_config allows the requested reset */
1096 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1097 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1098 {
1099 LOG_ERROR("BUG: requested reset would assert trst");
1100 jtag_error=ERROR_FAIL;
1101 return;
1102 }
1103
1104 /* if TRST pulls SRST, we reset with TAP T-L-R */
1105 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1106 {
1107 trst_with_tlr = 1;
1108 }
1109
1110 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1111 {
1112 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1113 jtag_error=ERROR_FAIL;
1114 return;
1115 }
1116
1117 if (req_tlr_or_trst)
1118 {
1119 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1120 {
1121 jtag_trst = 1;
1122 } else
1123 {
1124 trst_with_tlr = 1;
1125 }
1126 } else
1127 {
1128 jtag_trst = 0;
1129 }
1130
1131 jtag_srst = req_srst;
1132
1133 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1134 if (retval!=ERROR_OK)
1135 {
1136 jtag_error=retval;
1137 return;
1138 }
1139
1140 if (jtag_srst)
1141 {
1142 LOG_DEBUG("SRST line asserted");
1143 }
1144 else
1145 {
1146 LOG_DEBUG("SRST line released");
1147 if (jtag_nsrst_delay)
1148 jtag_add_sleep(jtag_nsrst_delay * 1000);
1149 }
1150
1151 if (trst_with_tlr)
1152 {
1153 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1154 jtag_add_end_state(TAP_RESET);
1155 jtag_add_tlr();
1156 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1157 return;
1158 }
1159
1160 if (jtag_trst)
1161 {
1162 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1163 * and inform possible listeners about this
1164 */
1165 LOG_DEBUG("TRST line asserted");
1166 cmd_queue_cur_state = TAP_RESET;
1167 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1168 }
1169 else
1170 {
1171 if (jtag_ntrst_delay)
1172 jtag_add_sleep(jtag_ntrst_delay * 1000);
1173 }
1174 }
1175
1176 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1177 {
1178 jtag_command_t **last_cmd = jtag_get_last_command_p();
1179
1180 /* allocate memory for a new list member */
1181 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1182 (*last_cmd)->next = NULL;
1183 last_comand_pointer = &((*last_cmd)->next);
1184 (*last_cmd)->type = JTAG_RESET;
1185
1186 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1187 (*last_cmd)->cmd.reset->trst = req_trst;
1188 (*last_cmd)->cmd.reset->srst = req_srst;
1189
1190 return ERROR_OK;
1191 }
1192
1193 void jtag_add_end_state(tap_state_t state)
1194 {
1195 cmd_queue_end_state = state;
1196 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1197 {
1198 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1199 }
1200 }
1201
1202 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1203 {
1204 jtag_command_t **last_cmd = jtag_get_last_command_p();
1205
1206 /* allocate memory for a new list member */
1207 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1208 (*last_cmd)->next = NULL;
1209 last_comand_pointer = &((*last_cmd)->next);
1210 (*last_cmd)->type = JTAG_SLEEP;
1211
1212 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1213 (*last_cmd)->cmd.sleep->us = us;
1214
1215 return ERROR_OK;
1216 }
1217
1218 void jtag_add_sleep(u32 us)
1219 {
1220 keep_alive(); /* we might be running on a very slow JTAG clk */
1221 int retval=interface_jtag_add_sleep(us);
1222 if (retval!=ERROR_OK)
1223 jtag_error=retval;
1224 return;
1225 }
1226
1227 int jtag_scan_size(scan_command_t *cmd)
1228 {
1229 int bit_count = 0;
1230 int i;
1231
1232 /* count bits in scan command */
1233 for (i = 0; i < cmd->num_fields; i++)
1234 {
1235 bit_count += cmd->fields[i].num_bits;
1236 }
1237
1238 return bit_count;
1239 }
1240
1241 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1242 {
1243 int bit_count = 0;
1244 int i;
1245
1246 bit_count = jtag_scan_size(cmd);
1247 *buffer = malloc(CEIL(bit_count, 8));
1248
1249 bit_count = 0;
1250
1251 #ifdef _DEBUG_JTAG_IO_
1252 LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
1253 #endif
1254
1255 for (i = 0; i < cmd->num_fields; i++)
1256 {
1257 if (cmd->fields[i].out_value)
1258 {
1259 #ifdef _DEBUG_JTAG_IO_
1260 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : cmd->fields[i].num_bits, 16);
1261 #endif
1262 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1263 #ifdef _DEBUG_JTAG_IO_
1264 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1265 free(char_buf);
1266 #endif
1267 }
1268 else
1269 {
1270 #ifdef _DEBUG_JTAG_IO_
1271 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
1272 #endif
1273 }
1274
1275 bit_count += cmd->fields[i].num_bits;
1276 }
1277
1278 #ifdef _DEBUG_JTAG_IO_
1279 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1280 #endif
1281
1282 return bit_count;
1283 }
1284
1285 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1286 {
1287 int i;
1288 int bit_count = 0;
1289 int retval;
1290
1291 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1292 retval = ERROR_OK;
1293
1294 for (i = 0; i < cmd->num_fields; i++)
1295 {
1296 /* if neither in_value nor in_handler
1297 * are specified we don't have to examine this field
1298 */
1299 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1300 {
1301 int num_bits = cmd->fields[i].num_bits;
1302 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1303
1304 #ifdef _DEBUG_JTAG_IO_
1305 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1306 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1307 free(char_buf);
1308 #endif
1309
1310 if (cmd->fields[i].in_value)
1311 {
1312 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1313
1314 if (cmd->fields[i].in_handler)
1315 {
1316 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1317 {
1318 LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1319 retval = ERROR_JTAG_QUEUE_FAILED;
1320 }
1321 }
1322 }
1323
1324 /* no in_value specified, but a handler takes care of the scanned data */
1325 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1326 {
1327 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1328 {
1329 /* We're going to call the error:handler later, but if the in_handler
1330 * reported an error we report this failure upstream
1331 */
1332 LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1333 retval = ERROR_JTAG_QUEUE_FAILED;
1334 }
1335 }
1336
1337 free(captured);
1338 }
1339 bit_count += cmd->fields[i].num_bits;
1340 }
1341
1342 return retval;
1343 }
1344
1345 static const char *jtag_tap_name(jtag_tap_t *tap)
1346 {
1347 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1348 }
1349
1350 int jtag_check_value_inner(u8 *captured, scan_field_t *field, u8 *in_check_value, u8 *in_check_mask)
1351 {
1352 int retval = ERROR_OK;
1353 int num_bits = field->num_bits;
1354
1355 int compare_failed = 0;
1356
1357 if (field->in_check_mask)
1358 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
1359 else
1360 compare_failed = buf_cmp(captured, in_check_value, num_bits);
1361
1362 if (compare_failed){
1363 /* An error handler could have caught the failing check
1364 * only report a problem when there wasn't a handler, or if the handler
1365 * acknowledged the error
1366 */
1367 LOG_WARNING("TAP %s:",
1368 jtag_tap_name(field->tap));
1369 if (compare_failed)
1370 {
1371 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1372 char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1373
1374 if (in_check_mask)
1375 {
1376 char *in_check_mask_char;
1377 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1378 LOG_WARNING("value captured during scan didn't pass the requested check:");
1379 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1380 captured_char, in_check_value_char, in_check_mask_char);
1381 free(in_check_mask_char);
1382 }
1383 else
1384 {
1385 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);
1386 }
1387
1388 free(captured_char);
1389 free(in_check_value_char);
1390
1391 retval = ERROR_JTAG_QUEUE_FAILED;
1392 }
1393
1394 }
1395 return retval;
1396 }
1397
1398 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1399 {
1400 return jtag_check_value_inner(captured, field, field->in_check_value, field->in_check_mask);
1401 }
1402
1403 /*
1404 set up checking of this field using the in_handler. The values passed in must be valid until
1405 after jtag_execute() has completed.
1406 */
1407 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, struct invalidstruct *obsolete)
1408 {
1409 if (value)
1410 field->in_handler = jtag_check_value;
1411 else
1412 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1413 field->in_handler_priv = NULL;
1414 field->in_check_value = value;
1415 field->in_check_mask = mask;
1416 }
1417
1418 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
1419 {
1420 jtag_execute_queue_noclear();
1421
1422 int retval=jtag_check_value_inner(field->in_value, field, value, mask);
1423 jtag_set_error(retval);
1424
1425 }
1426
1427
1428
1429 enum scan_type jtag_scan_type(scan_command_t *cmd)
1430 {
1431 int i;
1432 int type = 0;
1433
1434 for (i = 0; i < cmd->num_fields; i++)
1435 {
1436 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1437 type |= SCAN_IN;
1438 if (cmd->fields[i].out_value)
1439 type |= SCAN_OUT;
1440 }
1441
1442 return type;
1443 }
1444
1445 int MINIDRIVER(interface_jtag_execute_queue)(void)
1446 {
1447 int retval;
1448
1449 if (jtag==NULL)
1450 {
1451 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1452 return ERROR_FAIL;
1453 }
1454
1455 retval = jtag->execute_queue();
1456
1457 cmd_queue_free();
1458
1459 jtag_command_queue = NULL;
1460 last_comand_pointer = &jtag_command_queue;
1461
1462 return retval;
1463 }
1464
1465 void jtag_execute_queue_noclear(void)
1466 {
1467 int retval=interface_jtag_execute_queue();
1468 /* we keep the first error */
1469 if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
1470 {
1471 jtag_error=retval;
1472 }
1473 }
1474
1475 int jtag_execute_queue(void)
1476 {
1477 int retval;
1478 jtag_execute_queue_noclear();
1479 retval=jtag_error;
1480 jtag_error=ERROR_OK;
1481 return retval;
1482 }
1483
1484 int jtag_reset_callback(enum jtag_event event, void *priv)
1485 {
1486 jtag_tap_t *tap = priv;
1487
1488 LOG_DEBUG("-");
1489
1490 if (event == JTAG_TRST_ASSERTED)
1491 {
1492 buf_set_ones(tap->cur_instr, tap->ir_length);
1493 tap->bypass = 1;
1494 }
1495
1496 return ERROR_OK;
1497 }
1498
1499 void jtag_sleep(u32 us)
1500 {
1501 alive_sleep(us/1000);
1502 }
1503
1504 /* Try to examine chain layout according to IEEE 1149.1 §12
1505 */
1506 int jtag_examine_chain(void)
1507 {
1508 jtag_tap_t *tap;
1509 scan_field_t field;
1510 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1511 int i;
1512 int bit_count;
1513 int device_count = 0;
1514 u8 zero_check = 0x0;
1515 u8 one_check = 0xff;
1516
1517 field.tap = NULL;
1518 field.num_bits = sizeof(idcode_buffer) * 8;
1519 field.out_value = idcode_buffer;
1520
1521 field.in_value = idcode_buffer;
1522
1523
1524 field.in_handler = NULL;
1525
1526 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1527 {
1528 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1529 }
1530
1531 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1532 jtag_execute_queue();
1533
1534 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1535 {
1536 zero_check |= idcode_buffer[i];
1537 one_check &= idcode_buffer[i];
1538 }
1539
1540 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1541 if ((zero_check == 0x00) || (one_check == 0xff))
1542 {
1543 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1544 return ERROR_JTAG_INIT_FAILED;
1545 }
1546
1547 /* point at the 1st tap */
1548 tap = jtag_NextEnabledTap(NULL);
1549 if( tap == NULL ){
1550 LOG_ERROR("JTAG: No taps enabled?");
1551 return ERROR_JTAG_INIT_FAILED;
1552 }
1553
1554 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1555 {
1556 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1557 if ((idcode & 1) == 0)
1558 {
1559 /* LSB must not be 0, this indicates a device in bypass */
1560 LOG_WARNING("Tap/Device does not have IDCODE");
1561 idcode=0;
1562
1563 bit_count += 1;
1564 }
1565 else
1566 {
1567 u32 manufacturer;
1568 u32 part;
1569 u32 version;
1570
1571 /* some devices, such as AVR will output all 1's instead of TDI
1572 input value at end of chain. */
1573 if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1574 {
1575 int unexpected=0;
1576 /* End of chain (invalid manufacturer ID)
1577 *
1578 * The JTAG examine is the very first thing that happens
1579 *
1580 * A single JTAG device requires only 64 bits to be read back correctly.
1581 *
1582 * The code below adds a check that the rest of the data scanned (640 bits)
1583 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1584 *
1585 * earlier and gives more helpful/explicit error messages.
1586 */
1587 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1588 {
1589 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1590 if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1591 {
1592 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1593 unexpected = 1;
1594 }
1595 }
1596
1597 break;
1598 }
1599
1600 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1601 manufacturer = EXTRACT_MFG(idcode);
1602 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1603 part = EXTRACT_PART(idcode);
1604 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1605 version = EXTRACT_VER(idcode);
1606
1607 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1608 ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1609 idcode, manufacturer, part, version);
1610
1611 bit_count += 32;
1612 }
1613 if (tap)
1614 {
1615 tap->idcode = idcode;
1616
1617 if (tap->expected_ids_cnt > 0) {
1618 /* Loop over the expected identification codes and test for a match */
1619 u8 ii;
1620 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1621 if( tap->idcode == tap->expected_ids[ii] ){
1622 break;
1623 }
1624 }
1625
1626 /* If none of the expected ids matched, log an error */
1627 if (ii == tap->expected_ids_cnt) {
1628 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1629 tap->dotted_name,
1630 idcode,
1631 EXTRACT_MFG( tap->idcode ),
1632 EXTRACT_PART( tap->idcode ),
1633 EXTRACT_VER( tap->idcode ) );
1634 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1635 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1636 tap->dotted_name,
1637 ii + 1,
1638 tap->expected_ids_cnt,
1639 tap->expected_ids[ii],
1640 EXTRACT_MFG( tap->expected_ids[ii] ),
1641 EXTRACT_PART( tap->expected_ids[ii] ),
1642 EXTRACT_VER( tap->expected_ids[ii] ) );
1643 }
1644
1645 return ERROR_JTAG_INIT_FAILED;
1646 } else {
1647 LOG_INFO("JTAG Tap/device matched");
1648 }
1649 } else {
1650 #if 0
1651 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1652 tap->idcode);
1653 #endif
1654 }
1655 tap = jtag_NextEnabledTap(tap);
1656 }
1657 device_count++;
1658 }
1659
1660 /* see if number of discovered devices matches configuration */
1661 if (device_count != jtag_NumEnabledTaps())
1662 {
1663 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1664 device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1665 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1666 return ERROR_JTAG_INIT_FAILED;
1667 }
1668
1669 return ERROR_OK;
1670 }
1671
1672 int jtag_validate_chain(void)
1673 {
1674 jtag_tap_t *tap;
1675 int total_ir_length = 0;
1676 u8 *ir_test = NULL;
1677 scan_field_t field;
1678 int chain_pos = 0;
1679
1680 tap = NULL;
1681 total_ir_length = 0;
1682 for(;;){
1683 tap = jtag_NextEnabledTap(tap);
1684 if( tap == NULL ){
1685 break;
1686 }
1687 total_ir_length += tap->ir_length;
1688 }
1689
1690 total_ir_length += 2;
1691 ir_test = malloc(CEIL(total_ir_length, 8));
1692 buf_set_ones(ir_test, total_ir_length);
1693
1694 field.tap = NULL;
1695 field.num_bits = total_ir_length;
1696 field.out_value = ir_test;
1697 field.in_value = ir_test;
1698 field.in_handler = NULL;
1699
1700 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1701 jtag_execute_queue();
1702
1703 tap = NULL;
1704 chain_pos = 0;
1705 int val;
1706 for(;;){
1707 tap = jtag_NextEnabledTap(tap);
1708 if( tap == NULL ){
1709 break;
1710 }
1711
1712 val = buf_get_u32(ir_test, chain_pos, 2);
1713 if (val != 0x1)
1714 {
1715 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1716 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);
1717 free(cbuf);
1718 free(ir_test);
1719 return ERROR_JTAG_INIT_FAILED;
1720 }
1721 chain_pos += tap->ir_length;
1722 }
1723
1724 val = buf_get_u32(ir_test, chain_pos, 2);
1725 if (val != 0x3)
1726 {
1727 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1728 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);
1729 free(cbuf);
1730 free(ir_test);
1731 return ERROR_JTAG_INIT_FAILED;
1732 }
1733
1734 free(ir_test);
1735
1736 return ERROR_OK;
1737 }
1738
1739 enum jtag_tap_cfg_param {
1740 JCFG_EVENT
1741 };
1742
1743 static Jim_Nvp nvp_config_opts[] = {
1744 { .name = "-event", .value = JCFG_EVENT },
1745
1746 { .name = NULL, .value = -1 }
1747 };
1748
1749 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1750 {
1751 Jim_Nvp *n;
1752 Jim_Obj *o;
1753 int e;
1754
1755 /* parse config or cget options */
1756 while (goi->argc > 0) {
1757 Jim_SetEmptyResult (goi->interp);
1758
1759 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1760 if (e != JIM_OK) {
1761 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1762 return e;
1763 }
1764
1765 switch (n->value) {
1766 case JCFG_EVENT:
1767 if (goi->argc == 0) {
1768 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1769 return JIM_ERR;
1770 }
1771
1772 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1773 if (e != JIM_OK) {
1774 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1775 return e;
1776 }
1777
1778 if (goi->isconfigure) {
1779 if (goi->argc != 1) {
1780 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1781 return JIM_ERR;
1782 }
1783 } else {
1784 if (goi->argc != 0) {
1785 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1786 return JIM_ERR;
1787 }
1788 }
1789
1790 {
1791 jtag_tap_event_action_t *jteap;
1792
1793 jteap = tap->event_action;
1794 /* replace existing? */
1795 while (jteap) {
1796 if (jteap->event == (enum jtag_tap_event)n->value) {
1797 break;
1798 }
1799 jteap = jteap->next;
1800 }
1801
1802 if (goi->isconfigure) {
1803 if (jteap == NULL) {
1804 /* create new */
1805 jteap = calloc(1, sizeof (*jteap));
1806 }
1807 jteap->event = n->value;
1808 Jim_GetOpt_Obj( goi, &o);
1809 if (jteap->body) {
1810 Jim_DecrRefCount(interp, jteap->body);
1811 }
1812 jteap->body = Jim_DuplicateObj(goi->interp, o);
1813 Jim_IncrRefCount(jteap->body);
1814
1815 /* add to head of event list */
1816 jteap->next = tap->event_action;
1817 tap->event_action = jteap;
1818 Jim_SetEmptyResult(goi->interp);
1819 } else {
1820 /* get */
1821 if (jteap == NULL) {
1822 Jim_SetEmptyResult(goi->interp);
1823 } else {
1824 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1825 }
1826 }
1827 }
1828 /* loop for more */
1829 break;
1830 }
1831 } /* while (goi->argc) */
1832
1833 return JIM_OK;
1834 }
1835
1836 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1837 {
1838 jtag_tap_t *pTap;
1839 jtag_tap_t **ppTap;
1840 jim_wide w;
1841 int x;
1842 int e;
1843 int reqbits;
1844 Jim_Nvp *n;
1845 char *cp;
1846 const Jim_Nvp opts[] = {
1847 #define NTAP_OPT_IRLEN 0
1848 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1849 #define NTAP_OPT_IRMASK 1
1850 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1851 #define NTAP_OPT_IRCAPTURE 2
1852 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1853 #define NTAP_OPT_ENABLED 3
1854 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1855 #define NTAP_OPT_DISABLED 4
1856 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1857 #define NTAP_OPT_EXPECTED_ID 5
1858 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1859 { .name = NULL , .value = -1 },
1860 };
1861
1862 pTap = malloc( sizeof(jtag_tap_t) );
1863 memset( pTap, 0, sizeof(*pTap) );
1864 if( !pTap ){
1865 Jim_SetResult_sprintf( goi->interp, "no memory");
1866 return JIM_ERR;
1867 }
1868 /*
1869 * we expect CHIP + TAP + OPTIONS
1870 * */
1871 if( goi->argc < 3 ){
1872 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1873 return JIM_ERR;
1874 }
1875 Jim_GetOpt_String( goi, &cp, NULL );
1876 pTap->chip = strdup(cp);
1877
1878 Jim_GetOpt_String( goi, &cp, NULL );
1879 pTap->tapname = strdup(cp);
1880
1881 /* name + dot + name + null */
1882 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1883 cp = malloc( x );
1884 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1885 pTap->dotted_name = cp;
1886
1887 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1888 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1889
1890 /* default is enabled */
1891 pTap->enabled = 1;
1892
1893 /* deal with options */
1894 #define NTREQ_IRLEN 1
1895 #define NTREQ_IRCAPTURE 2
1896 #define NTREQ_IRMASK 4
1897
1898 /* clear them as we find them */
1899 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1900
1901 while( goi->argc ){
1902 e = Jim_GetOpt_Nvp( goi, opts, &n );
1903 if( e != JIM_OK ){
1904 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1905 return e;
1906 }
1907 LOG_DEBUG("Processing option: %s", n->name );
1908 switch( n->value ){
1909 case NTAP_OPT_ENABLED:
1910 pTap->enabled = 1;
1911 break;
1912 case NTAP_OPT_DISABLED:
1913 pTap->enabled = 0;
1914 break;
1915 case NTAP_OPT_EXPECTED_ID:
1916 {
1917 u32 *new_expected_ids;
1918
1919 e = Jim_GetOpt_Wide( goi, &w );
1920 if( e != JIM_OK) {
1921 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1922 return e;
1923 }
1924
1925 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1926 if (new_expected_ids == NULL) {
1927 Jim_SetResult_sprintf( goi->interp, "no memory");
1928 return JIM_ERR;
1929 }
1930
1931 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1932
1933 new_expected_ids[pTap->expected_ids_cnt] = w;
1934
1935 free(pTap->expected_ids);
1936 pTap->expected_ids = new_expected_ids;
1937 pTap->expected_ids_cnt++;
1938 break;
1939 }
1940 case NTAP_OPT_IRLEN:
1941 case NTAP_OPT_IRMASK:
1942 case NTAP_OPT_IRCAPTURE:
1943 e = Jim_GetOpt_Wide( goi, &w );
1944 if( e != JIM_OK ){
1945 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1946 return e;
1947 }
1948 if( (w < 0) || (w > 0xffff) ){
1949 /* wacky value */
1950 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1951 n->name, (int)(w), (int)(w));
1952 return JIM_ERR;
1953 }
1954 switch(n->value){
1955 case NTAP_OPT_IRLEN:
1956 pTap->ir_length = w;
1957 reqbits &= (~(NTREQ_IRLEN));
1958 break;
1959 case NTAP_OPT_IRMASK:
1960 pTap->ir_capture_mask = w;
1961 reqbits &= (~(NTREQ_IRMASK));
1962 break;
1963 case NTAP_OPT_IRCAPTURE:
1964 pTap->ir_capture_value = w;
1965 reqbits &= (~(NTREQ_IRCAPTURE));
1966 break;
1967 }
1968 } /* switch(n->value) */
1969 } /* while( goi->argc ) */
1970
1971 /* Did we get all the options? */
1972 if( reqbits ){
1973 // no
1974 Jim_SetResult_sprintf( goi->interp,
1975 "newtap: %s missing required parameters",
1976 pTap->dotted_name);
1977 /* TODO: Tell user what is missing :-( */
1978 /* no memory leaks pelase */
1979 free(((void *)(pTap->expected_ids)));
1980 free(((void *)(pTap->chip)));
1981 free(((void *)(pTap->tapname)));
1982 free(((void *)(pTap->dotted_name)));
1983 free(((void *)(pTap)));
1984 return JIM_ERR;
1985 }
1986
1987 pTap->expected = malloc( pTap->ir_length );
1988 pTap->expected_mask = malloc( pTap->ir_length );
1989 pTap->cur_instr = malloc( pTap->ir_length );
1990
1991 buf_set_u32( pTap->expected,
1992 0,
1993 pTap->ir_length,
1994 pTap->ir_capture_value );
1995 buf_set_u32( pTap->expected_mask,
1996 0,
1997 pTap->ir_length,
1998 pTap->ir_capture_mask );
1999 buf_set_ones( pTap->cur_instr,
2000 pTap->ir_length );
2001
2002 pTap->bypass = 1;
2003
2004 jtag_register_event_callback(jtag_reset_callback, pTap );
2005
2006 ppTap = &(jtag_all_taps);
2007 while( (*ppTap) != NULL ){
2008 ppTap = &((*ppTap)->next_tap);
2009 }
2010 *ppTap = pTap;
2011 {
2012 static int n_taps = 0;
2013 pTap->abs_chain_position = n_taps++;
2014 }
2015 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
2016 (*ppTap)->dotted_name,
2017 (*ppTap)->abs_chain_position,
2018 (*ppTap)->ir_length,
2019 (*ppTap)->ir_capture_value,
2020 (*ppTap)->ir_capture_mask );
2021
2022 return ERROR_OK;
2023 }
2024
2025 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
2026 {
2027 Jim_GetOptInfo goi;
2028 int e;
2029 Jim_Nvp *n;
2030 Jim_Obj *o;
2031 struct command_context_s *context;
2032
2033 enum {
2034 JTAG_CMD_INTERFACE,
2035 JTAG_CMD_INIT_RESET,
2036 JTAG_CMD_NEWTAP,
2037 JTAG_CMD_TAPENABLE,
2038 JTAG_CMD_TAPDISABLE,
2039 JTAG_CMD_TAPISENABLED,
2040 JTAG_CMD_CONFIGURE,
2041 JTAG_CMD_CGET
2042 };
2043
2044 const Jim_Nvp jtag_cmds[] = {
2045 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2046 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2047 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2048 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2049 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2050 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2051 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2052 { .name = "cget" , .value = JTAG_CMD_CGET },
2053
2054 { .name = NULL, .value = -1 },
2055 };
2056
2057 context = Jim_GetAssocData(interp, "context");
2058 /* go past the command */
2059 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2060
2061 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2062 if( e != JIM_OK ){
2063 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2064 return e;
2065 }
2066 Jim_SetEmptyResult( goi.interp );
2067 switch( n->value ){
2068 case JTAG_CMD_INTERFACE:
2069 /* return the name of the interface */
2070 /* TCL code might need to know the exact type... */
2071 /* FUTURE: we allow this as a means to "set" the interface. */
2072 if( goi.argc != 0 ){
2073 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2074 return JIM_ERR;
2075 }
2076 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2077 return JIM_OK;
2078 case JTAG_CMD_INIT_RESET:
2079 if( goi.argc != 0 ){
2080 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2081 return JIM_ERR;
2082 }
2083 e = jtag_init_reset(context);
2084 if( e != ERROR_OK ){
2085 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2086 return JIM_ERR;
2087 }
2088 return JIM_OK;
2089 case JTAG_CMD_NEWTAP:
2090 return jim_newtap_cmd( &goi );
2091 break;
2092 case JTAG_CMD_TAPISENABLED:
2093 case JTAG_CMD_TAPENABLE:
2094 case JTAG_CMD_TAPDISABLE:
2095 if( goi.argc != 1 ){
2096 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2097 return JIM_ERR;
2098 }
2099
2100 {
2101 jtag_tap_t *t;
2102 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2103 if( t == NULL ){
2104 return JIM_ERR;
2105 }
2106 switch( n->value ){
2107 case JTAG_CMD_TAPISENABLED:
2108 e = t->enabled;
2109 break;
2110 case JTAG_CMD_TAPENABLE:
2111 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2112 e = 1;
2113 t->enabled = e;
2114 break;
2115 case JTAG_CMD_TAPDISABLE:
2116 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2117 e = 0;
2118 t->enabled = e;
2119 break;
2120 }
2121 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2122 return JIM_OK;
2123 }
2124 break;
2125
2126 case JTAG_CMD_CGET:
2127 if( goi.argc < 2 ){
2128 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2129 return JIM_ERR;
2130 }
2131
2132 {
2133 jtag_tap_t *t;
2134
2135 Jim_GetOpt_Obj(&goi, &o);
2136 t = jtag_TapByJimObj( goi.interp, o );
2137 if( t == NULL ){
2138 return JIM_ERR;
2139 }
2140
2141 goi.isconfigure = 0;
2142 return jtag_tap_configure_cmd( &goi, t);
2143 }
2144 break;
2145
2146 case JTAG_CMD_CONFIGURE:
2147 if( goi.argc < 3 ){
2148 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2149 return JIM_ERR;
2150 }
2151
2152 {
2153 jtag_tap_t *t;
2154
2155 Jim_GetOpt_Obj(&goi, &o);
2156 t = jtag_TapByJimObj( goi.interp, o );
2157 if( t == NULL ){
2158 return JIM_ERR;
2159 }
2160
2161 goi.isconfigure = 1;
2162 return jtag_tap_configure_cmd( &goi, t);
2163 }
2164 }
2165
2166 return JIM_ERR;
2167 }
2168
2169 int jtag_register_commands(struct command_context_s *cmd_ctx)
2170 {
2171 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2172
2173 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2174 COMMAND_CONFIG, "try to configure interface");
2175 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2176 COMMAND_ANY, "set jtag speed (if supported)");
2177 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2178 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2179 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2180 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2181 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2182 COMMAND_ANY,
2183 "[none/trst_only/srst_only/trst_and_srst] [srst_pulls_trst/trst_pulls_srst] [combined/separate] [trst_push_pull/trst_open_drain] [srst_push_pull/srst_open_drain]");
2184 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2185 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2186 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2187 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2188
2189 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2190 COMMAND_EXEC, "print current scan chain configuration");
2191
2192 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2193 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2194 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2195 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2196 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2197 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2198 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2199 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2200 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2201
2202 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2203 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2204 return ERROR_OK;
2205 }
2206
2207 int jtag_interface_init(struct command_context_s *cmd_ctx)
2208 {
2209 if (jtag)
2210 return ERROR_OK;
2211
2212 if (!jtag_interface)
2213 {
2214 /* nothing was previously specified by "interface" command */
2215 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2216 return ERROR_JTAG_INVALID_INTERFACE;
2217 }
2218 if(hasKHz)
2219 {
2220 jtag_interface->khz(speed_khz, &jtag_speed);
2221 hasKHz = 0;
2222 }
2223
2224 if (jtag_interface->init() != ERROR_OK)
2225 return ERROR_JTAG_INIT_FAILED;
2226
2227 jtag = jtag_interface;
2228 return ERROR_OK;
2229 }
2230
2231 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2232 {
2233 jtag_tap_t *tap;
2234 int retval;
2235
2236 LOG_DEBUG("Init JTAG chain");
2237
2238 tap = jtag_NextEnabledTap(NULL);
2239 if( tap == NULL ){
2240 LOG_ERROR("There are no enabled taps?");
2241 return ERROR_JTAG_INIT_FAILED;
2242 }
2243
2244 jtag_add_tlr();
2245 if ((retval=jtag_execute_queue())!=ERROR_OK)
2246 return retval;
2247
2248 /* examine chain first, as this could discover the real chain layout */
2249 if (jtag_examine_chain() != ERROR_OK)
2250 {
2251 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2252 }
2253
2254 if (jtag_validate_chain() != ERROR_OK)
2255 {
2256 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2257 }
2258
2259 return ERROR_OK;
2260 }
2261
2262 int jtag_init_reset(struct command_context_s *cmd_ctx)
2263 {
2264 int retval;
2265
2266 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2267 return retval;
2268
2269 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2270
2271 /* Reset can happen after a power cycle.
2272 *
2273 * Ideally we would only assert TRST or run RESET before the target reset.
2274 *
2275 * However w/srst_pulls_trst, trst is asserted together with the target
2276 * reset whether we want it or not.
2277 *
2278 * NB! Some targets have JTAG circuitry disabled until a
2279 * trst & srst has been asserted.
2280 *
2281 * NB! here we assume nsrst/ntrst delay are sufficient!
2282 *
2283 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2284 *
2285 */
2286 jtag_add_reset(1, 0); /* RESET or TRST */
2287 if (jtag_reset_config & RESET_HAS_SRST)
2288 {
2289 jtag_add_reset(1, 1);
2290 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2291 jtag_add_reset(0, 1);
2292 }
2293 jtag_add_reset(0, 0);
2294 if ((retval = jtag_execute_queue()) != ERROR_OK)
2295 return retval;
2296
2297 /* Check that we can communication on the JTAG chain + eventually we want to
2298 * be able to perform enumeration only after OpenOCD has started
2299 * telnet and GDB server
2300 *
2301 * That would allow users to more easily perform any magic they need to before
2302 * reset happens.
2303 */
2304 return jtag_init_inner(cmd_ctx);
2305 }
2306
2307 int jtag_init(struct command_context_s *cmd_ctx)
2308 {
2309 int retval;
2310 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2311 return retval;
2312 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2313 {
2314 return ERROR_OK;
2315 }
2316 return jtag_init_reset(cmd_ctx);
2317 }
2318
2319 static int default_khz(int khz, int *jtag_speed)
2320 {
2321 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2322 return ERROR_FAIL;
2323 }
2324
2325 static int default_speed_div(int speed, int *khz)
2326 {
2327 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2328 return ERROR_FAIL;
2329 }
2330
2331 static int default_power_dropout(int *dropout)
2332 {
2333 *dropout=0; /* by default we can't detect power dropout */
2334 return ERROR_OK;
2335 }
2336
2337 static int default_srst_asserted(int *srst_asserted)
2338 {
2339 *srst_asserted=0; /* by default we can't detect srst asserted */
2340 return ERROR_OK;
2341 }
2342
2343 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2344 {
2345 int i;
2346 int retval;
2347
2348 /* check whether the interface is already configured */
2349 if (jtag_interface)
2350 {
2351 LOG_WARNING("Interface already configured, ignoring");
2352 return ERROR_OK;
2353 }
2354
2355 /* interface name is a mandatory argument */
2356 if (argc < 1 || args[0][0] == '\0')
2357 {
2358 return ERROR_COMMAND_SYNTAX_ERROR;
2359 }
2360
2361 for (i=0; jtag_interfaces[i]; i++)
2362 {
2363 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2364 {
2365 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2366 {
2367 return retval;
2368 }
2369
2370 jtag_interface = jtag_interfaces[i];
2371
2372 if (jtag_interface->khz == NULL)
2373 {
2374 jtag_interface->khz = default_khz;
2375 }
2376 if (jtag_interface->speed_div == NULL)
2377 {
2378 jtag_interface->speed_div = default_speed_div;
2379 }
2380 if (jtag_interface->power_dropout == NULL)
2381 {
2382 jtag_interface->power_dropout = default_power_dropout;
2383 }
2384 if (jtag_interface->srst_asserted == NULL)
2385 {
2386 jtag_interface->srst_asserted = default_srst_asserted;
2387 }
2388
2389 return ERROR_OK;
2390 }
2391 }
2392
2393 /* no valid interface was found (i.e. the configuration option,
2394 * didn't match one of the compiled-in interfaces
2395 */
2396 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2397 LOG_ERROR("compiled-in jtag interfaces:");
2398 for (i = 0; jtag_interfaces[i]; i++)
2399 {
2400 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2401 }
2402
2403 return ERROR_JTAG_INVALID_INTERFACE;
2404 }
2405
2406 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2407 {
2408 int e;
2409 char buf[1024];
2410 Jim_Obj *newargs[ 10 ];
2411 /*
2412 * CONVERT SYNTAX
2413 * argv[-1] = command
2414 * argv[ 0] = ir length
2415 * argv[ 1] = ir capture
2416 * argv[ 2] = ir mask
2417 * argv[ 3] = not actually used by anything but in the docs
2418 */
2419
2420 if( argc < 4 ){
2421 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2422 return ERROR_OK;
2423 }
2424 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2425 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2426 args[0],
2427 args[1],
2428 args[2] );
2429 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2430 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2431 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2432 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2433
2434 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2435 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2436 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2437 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2438 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2439 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2440 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2441 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2442 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2443 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2444 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2445 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2446
2447 command_print( cmd_ctx, "NEW COMMAND:");
2448 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2449 Jim_GetString( newargs[0], NULL ),
2450 Jim_GetString( newargs[1], NULL ),
2451 Jim_GetString( newargs[2], NULL ),
2452 Jim_GetString( newargs[3], NULL ),
2453 Jim_GetString( newargs[4], NULL ),
2454 Jim_GetString( newargs[5], NULL ),
2455 Jim_GetString( newargs[6], NULL ),
2456 Jim_GetString( newargs[7], NULL ),
2457 Jim_GetString( newargs[8], NULL ),
2458 Jim_GetString( newargs[9], NULL ) );
2459
2460 e = jim_jtag_command( interp, 10, newargs );
2461 if( e != JIM_OK ){
2462 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2463 }
2464 return e;
2465 }
2466
2467 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2468 {
2469 jtag_tap_t *tap;
2470
2471 tap = jtag_all_taps;
2472 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2473 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2474
2475 while( tap ){
2476 u32 expected, expected_mask, cur_instr, ii;
2477 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2478 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2479 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2480
2481 command_print(cmd_ctx,
2482 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2483 tap->abs_chain_position,
2484 tap->dotted_name,
2485 tap->enabled ? 'Y' : 'n',
2486 tap->idcode,
2487 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2488 tap->ir_length,
2489 expected,
2490 expected_mask,
2491 cur_instr);
2492
2493 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2494 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2495 tap->expected_ids[ii]);
2496 }
2497
2498 tap = tap->next_tap;
2499 }
2500
2501 return ERROR_OK;
2502 }
2503
2504 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2505 {
2506 if (argc < 1)
2507 return ERROR_COMMAND_SYNTAX_ERROR;
2508
2509 if (argc >= 1)
2510 {
2511 if (strcmp(args[0], "none") == 0)
2512 jtag_reset_config = RESET_NONE;
2513 else if (strcmp(args[0], "trst_only") == 0)
2514 jtag_reset_config = RESET_HAS_TRST;
2515 else if (strcmp(args[0], "srst_only") == 0)
2516 jtag_reset_config = RESET_HAS_SRST;
2517 else if (strcmp(args[0], "trst_and_srst") == 0)
2518 jtag_reset_config = RESET_TRST_AND_SRST;
2519 else
2520 {
2521 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2522 jtag_reset_config = RESET_NONE;
2523 return ERROR_INVALID_ARGUMENTS;
2524 }
2525 }
2526
2527 if (argc >= 2)
2528 {
2529 if (strcmp(args[1], "separate") == 0)
2530 {
2531 /* seperate reset lines - default */
2532 } else
2533 {
2534 if (strcmp(args[1], "srst_pulls_trst") == 0)
2535 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2536 else if (strcmp(args[1], "trst_pulls_srst") == 0)
2537 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2538 else if (strcmp(args[1], "combined") == 0)
2539 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2540 else
2541 {
2542 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2543 jtag_reset_config = RESET_NONE;
2544 return ERROR_INVALID_ARGUMENTS;
2545 }
2546 }
2547 }
2548
2549 if (argc >= 3)
2550 {
2551 if (strcmp(args[2], "trst_open_drain") == 0)
2552 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2553 else if (strcmp(args[2], "trst_push_pull") == 0)
2554 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2555 else
2556 {
2557 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2558 jtag_reset_config = RESET_NONE;
2559 return ERROR_INVALID_ARGUMENTS;
2560 }
2561 }
2562
2563 if (argc >= 4)
2564 {
2565 if (strcmp(args[3], "srst_push_pull") == 0)
2566 jtag_reset_config |= RESET_SRST_PUSH_PULL;
2567 else if (strcmp(args[3], "srst_open_drain") == 0)
2568 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2569 else
2570 {
2571 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2572 jtag_reset_config = RESET_NONE;
2573 return ERROR_INVALID_ARGUMENTS;
2574 }
2575 }
2576
2577 return ERROR_OK;
2578 }
2579
2580 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2581 {
2582 if (argc < 1)
2583 {
2584 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2585 exit(-1);
2586 }
2587 else
2588 {
2589 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2590 }
2591
2592 return ERROR_OK;
2593 }
2594
2595 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2596 {
2597 if (argc < 1)
2598 {
2599 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2600 exit(-1);
2601 }
2602 else
2603 {
2604 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2605 }
2606
2607 return ERROR_OK;
2608 }
2609
2610 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2611 {
2612 int retval=ERROR_OK;
2613
2614 if (argc == 1)
2615 {
2616 LOG_DEBUG("handle jtag speed");
2617
2618 int cur_speed = 0;
2619 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2620
2621 /* this command can be called during CONFIG,
2622 * in which case jtag isn't initialized */
2623 if (jtag)
2624 {
2625 retval=jtag->speed(cur_speed);
2626 }
2627 } else if (argc == 0)
2628 {
2629 } else
2630 {
2631 return ERROR_COMMAND_SYNTAX_ERROR;
2632 }
2633 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2634
2635 return retval;
2636 }
2637
2638 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2639 {
2640 int retval=ERROR_OK;
2641 LOG_DEBUG("handle jtag khz");
2642
2643 if(argc == 1)
2644 {
2645 speed_khz = strtoul(args[0], NULL, 0);
2646 if (jtag != NULL)
2647 {
2648 int cur_speed = 0;
2649 LOG_DEBUG("have interface set up");
2650 int speed_div1;
2651 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2652 {
2653 speed_khz = 0;
2654 return retval;
2655 }
2656
2657 cur_speed = jtag_speed = speed_div1;
2658
2659 retval=jtag->speed(cur_speed);
2660 } else
2661 {
2662 hasKHz = 1;
2663 }
2664 } else if (argc==0)
2665 {
2666 } else
2667 {
2668 return ERROR_COMMAND_SYNTAX_ERROR;
2669 }
2670
2671 if (jtag!=NULL)
2672 {
2673 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2674 return retval;
2675 }
2676
2677 if (speed_khz==0)
2678 {
2679 command_print(cmd_ctx, "RCLK - adaptive");
2680 } else
2681 {
2682 command_print(cmd_ctx, "%d kHz", speed_khz);
2683 }
2684 return retval;
2685
2686 }
2687
2688 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2689 {
2690 tap_state_t state;
2691
2692 if (argc < 1)
2693 {
2694 return ERROR_COMMAND_SYNTAX_ERROR;
2695 }
2696 else
2697 {
2698 state = tap_state_by_name( args[0] );
2699 if( state < 0 ){
2700 command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2701 return ERROR_COMMAND_SYNTAX_ERROR;
2702 }
2703 jtag_add_end_state(state);
2704 jtag_execute_queue();
2705 }
2706 command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2707
2708 return ERROR_OK;
2709 }
2710
2711 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2712 {
2713 int trst = -1;
2714 int srst = -1;
2715
2716 if (argc < 2)
2717 {
2718 return ERROR_COMMAND_SYNTAX_ERROR;
2719 }
2720
2721 if (args[0][0] == '1')
2722 trst = 1;
2723 else if (args[0][0] == '0')
2724 trst = 0;
2725 else
2726 {
2727 return ERROR_COMMAND_SYNTAX_ERROR;
2728 }
2729
2730 if (args[1][0] == '1')
2731 srst = 1;
2732 else if (args[1][0] == '0')
2733 srst = 0;
2734 else
2735 {
2736 return ERROR_COMMAND_SYNTAX_ERROR;
2737 }
2738
2739 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2740 return ERROR_JTAG_INIT_FAILED;
2741
2742 jtag_add_reset(trst, srst);
2743 jtag_execute_queue();
2744
2745 return ERROR_OK;
2746 }
2747
2748 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2749 {
2750 if (argc < 1)
2751 {
2752 return ERROR_COMMAND_SYNTAX_ERROR;
2753 }
2754
2755 jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2756 jtag_execute_queue();
2757
2758 return ERROR_OK;
2759
2760 }
2761
2762 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2763 {
2764 int i;
2765 scan_field_t *fields;
2766 jtag_tap_t *tap;
2767 tap_state_t endstate;
2768
2769 if ((argc < 2) || (argc % 2))
2770 {
2771 return ERROR_COMMAND_SYNTAX_ERROR;
2772 }
2773
2774 /* optional "-endstate" */
2775 /* "statename" */
2776 /* at the end of the arguments. */
2777 /* assume none. */
2778 endstate = TAP_INVALID;
2779 if( argc >= 4 ){
2780 /* have at least one pair of numbers. */
2781 /* is last pair the magic text? */
2782 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2783 const char *cpA;
2784 const char *cpS;
2785 cpA = args[ argc-1 ];
2786 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2787 cpS = tap_state_name( endstate );
2788 if( 0 == strcmp( cpA, cpS ) ){
2789 break;
2790 }
2791 }
2792 if( endstate >= TAP_NUM_STATES ){
2793 return ERROR_COMMAND_SYNTAX_ERROR;
2794 } else {
2795 /* found - remove the last 2 args */
2796 argc -= 2;
2797 }
2798 }
2799 }
2800
2801 fields = malloc(sizeof(scan_field_t) * argc / 2);
2802
2803 for (i = 0; i < argc / 2; i++)
2804 {
2805 tap = jtag_TapByString( args[i*2] );
2806 if (tap==NULL)
2807 {
2808 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2809 return ERROR_FAIL;
2810 }
2811 int field_size = tap->ir_length;
2812 fields[i].tap = tap;
2813 fields[i].out_value = malloc(CEIL(field_size, 8));
2814 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2815 fields[i].in_value = NULL;
2816 fields[i].in_check_mask = NULL;
2817 fields[i].in_handler = NULL;
2818 fields[i].in_handler_priv = NULL;
2819 }
2820
2821 jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
2822 /* did we have an endstate? */
2823 if (endstate != TAP_INVALID)
2824 jtag_add_end_state(endstate);
2825
2826 jtag_execute_queue();
2827
2828 for (i = 0; i < argc / 2; i++)
2829 free(fields[i].out_value);
2830
2831 free (fields);
2832
2833 return ERROR_OK;
2834 }
2835
2836 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2837 {
2838 int retval;
2839 scan_field_t *fields;
2840 int num_fields;
2841 int field_count = 0;
2842 int i, e;
2843 jtag_tap_t *tap;
2844 tap_state_t endstate;
2845
2846 /* args[1] = device
2847 * args[2] = num_bits
2848 * args[3] = hex string
2849 * ... repeat num bits and hex string ...
2850 *
2851 * .. optionally:
2852 * args[N-2] = "-endstate"
2853 * args[N-1] = statename
2854 */
2855 if ((argc < 4) || ((argc % 2)!=0))
2856 {
2857 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2858 return JIM_ERR;
2859 }
2860
2861 /* assume no endstate */
2862 endstate = TAP_INVALID;
2863 /* validate arguments as numbers */
2864 e = JIM_OK;
2865 for (i = 2; i < argc; i+=2)
2866 {
2867 long bits;
2868 const char *cp;
2869
2870 e = Jim_GetLong(interp, args[i], &bits);
2871 /* If valid - try next arg */
2872 if( e == JIM_OK ){
2873 continue;
2874 }
2875
2876 /* Not valid.. are we at the end? */
2877 if ( ((i+2) != argc) ){
2878 /* nope, then error */
2879 return e;
2880 }
2881
2882 /* it could be: "-endstate FOO" */
2883
2884 /* get arg as a string. */
2885 cp = Jim_GetString( args[i], NULL );
2886 /* is it the magic? */
2887 if( 0 == strcmp( "-endstate", cp ) ){
2888 /* is the statename valid? */
2889 cp = Jim_GetString( args[i+1], NULL );
2890
2891 /* see if it is a valid state name */
2892 endstate = tap_state_by_name(cp);
2893 if( endstate < 0 ){
2894 /* update the error message */
2895 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2896 } else {
2897 /* valid - so clear the error */
2898 e = JIM_OK;
2899 /* and remove the last 2 args */
2900 argc -= 2;
2901 }
2902 }
2903
2904 /* Still an error? */
2905 if( e != JIM_OK ){
2906 return e; /* too bad */
2907 }
2908 } /* validate args */
2909
2910 tap = jtag_TapByJimObj( interp, args[1] );
2911 if( tap == NULL ){
2912 return JIM_ERR;
2913 }
2914
2915 num_fields=(argc-2)/2;
2916 fields = malloc(sizeof(scan_field_t) * num_fields);
2917 for (i = 2; i < argc; i+=2)
2918 {
2919 long bits;
2920 int len;
2921 const char *str;
2922
2923 Jim_GetLong(interp, args[i], &bits);
2924 str = Jim_GetString(args[i+1], &len);
2925
2926 fields[field_count].tap = tap;
2927 fields[field_count].num_bits = bits;
2928 fields[field_count].out_value = malloc(CEIL(bits, 8));
2929 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2930 fields[field_count].in_value = fields[field_count].out_value;
2931 fields[field_count].in_check_mask = NULL;
2932 fields[field_count].in_check_value = NULL;
2933 fields[field_count].in_handler = NULL;
2934 fields[field_count++].in_handler_priv = NULL;
2935 }
2936
2937 jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
2938 /* did we get an end state? */
2939 if (endstate != TAP_INVALID)
2940 jtag_add_end_state(endstate);
2941
2942 retval = jtag_execute_queue();
2943 if (retval != ERROR_OK)
2944 {
2945 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2946 return JIM_ERR;
2947 }
2948
2949 field_count=0;
2950 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2951 for (i = 2; i < argc; i+=2)
2952 {
2953 long bits;
2954 char *str;
2955
2956 Jim_GetLong(interp, args[i], &bits);
2957 str = buf_to_str(fields[field_count].in_value, bits, 16);
2958 free(fields[field_count].out_value);
2959
2960 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2961 free(str);
2962 field_count++;
2963 }
2964
2965 Jim_SetResult(interp, list);
2966
2967 free(fields);
2968
2969 return JIM_OK;
2970 }
2971
2972 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2973 {
2974 if (argc == 1)
2975 {
2976 if (strcmp(args[0], "enable") == 0)
2977 {
2978 jtag_verify_capture_ir = 1;
2979 }
2980 else if (strcmp(args[0], "disable") == 0)
2981 {
2982 jtag_verify_capture_ir = 0;
2983 } else
2984 {
2985 return ERROR_COMMAND_SYNTAX_ERROR;
2986 }
2987 } else if (argc != 0)
2988 {
2989 return ERROR_COMMAND_SYNTAX_ERROR;
2990 }
2991
2992 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2993
2994 return ERROR_OK;
2995 }
2996
2997 int jtag_power_dropout(int *dropout)
2998 {
2999 return jtag->power_dropout(dropout);
3000 }
3001
3002 int jtag_srst_asserted(int *srst_asserted)
3003 {
3004 return jtag->srst_asserted(srst_asserted);
3005 }
3006
3007 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
3008 {
3009 jtag_tap_event_action_t * jteap;
3010 int done;
3011
3012 jteap = tap->event_action;
3013
3014 done = 0;
3015 while (jteap) {
3016 if (jteap->event == e) {
3017 done = 1;
3018 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
3019 tap->dotted_name,
3020 e,
3021 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
3022 Jim_GetString(jteap->body, NULL) );
3023 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
3024 Jim_PrintErrorMessage(interp);
3025 }
3026 }
3027
3028 jteap = jteap->next;
3029 }
3030
3031 if (!done) {
3032 LOG_DEBUG( "event %d %s - no action",
3033 e,
3034 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3035 }
3036 }
3037
3038 /*-----<Cable Helper API>---------------------------------------*/
3039
3040 /* these Cable Helper API functions are all documented in the jtag.h header file,
3041 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3042 is setup to prefer its docs in the header file, no documentation is here, for
3043 if it were, it would have to be doubly maintained.
3044 */
3045
3046 /**
3047 * @see tap_set_state() and tap_get_state() accessors.
3048 * Actual name is not important since accessors hide it.
3049 */
3050 static tap_state_t state_follower = TAP_RESET;
3051
3052 void tap_set_state_impl( tap_state_t new_state )
3053 {
3054 /* this is the state we think the TAPs are in now, was cur_state */
3055 state_follower = new_state;
3056 }
3057
3058 tap_state_t tap_get_state()
3059 {
3060 return state_follower;
3061 }
3062
3063 /**
3064 * @see tap_set_end_state() and tap_get_end_state() accessors.
3065 * Actual name is not important because accessors hide it.
3066 */
3067 static tap_state_t end_state_follower = TAP_RESET;
3068
3069 void tap_set_end_state( tap_state_t new_end_state )
3070 {
3071 /* this is the state we think the TAPs will be in at completion of the
3072 current TAP operation, was end_state
3073 */
3074 end_state_follower = new_end_state;
3075 }
3076
3077 tap_state_t tap_get_end_state()
3078 {
3079 return end_state_follower;
3080 }
3081
3082
3083 int tap_move_ndx( tap_state_t astate )
3084 {
3085 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3086
3087 int ndx;
3088
3089 switch( astate )
3090 {
3091 case TAP_RESET: ndx = 0; break;
3092 case TAP_DRSHIFT: ndx = 2; break;
3093 case TAP_DRPAUSE: ndx = 3; break;
3094 case TAP_IDLE: ndx = 1; break;
3095 case TAP_IRSHIFT: ndx = 4; break;
3096 case TAP_IRPAUSE: ndx = 5; break;
3097 default:
3098 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3099 exit(1);
3100 }
3101
3102 return ndx;
3103 }
3104
3105
3106 /* tap_move[i][j]: tap movement command to go from state i to state j
3107 * 0: Test-Logic-Reset
3108 * 1: Run-Test/Idle
3109 * 2: Shift-DR
3110 * 3: Pause-DR
3111 * 4: Shift-IR
3112 * 5: Pause-IR
3113 *
3114 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3115 */
3116 static struct
3117 {
3118 u8 bits;
3119 u8 bit_count;
3120
3121 } tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */
3122 {
3123 /* value clocked to TMS to move from one of six stable states to another.
3124 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3125 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3126 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3127 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3128 */
3129
3130 /*
3131 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3132 * Read the bits from LSBit first to MSBit last (right-to-left).
3133 */
3134 #define HEX__(n) 0x##n##LU
3135
3136 #define B8__(x) \
3137 (((x) & 0x0000000FLU)?(1<<0):0) \
3138 +(((x) & 0x000000F0LU)?(1<<1):0) \
3139 +(((x) & 0x00000F00LU)?(1<<2):0) \
3140 +(((x) & 0x0000F000LU)?(1<<3):0) \
3141 +(((x) & 0x000F0000LU)?(1<<4):0) \
3142 +(((x) & 0x00F00000LU)?(1<<5):0) \
3143 +(((x) & 0x0F000000LU)?(1<<6):0) \
3144 +(((x) & 0xF0000000LU)?(1<<7):0)
3145
3146 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3147
3148 #if 0 && ((BUILD_FT2232_FTD2XX==1) || (BUILD_FT2232_LIBFTDI==1) || (BUILD_JLINK==1))
3149 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3150
3151 OK, I added Peter's version of the state table, and it works OK for
3152 me on MC1322x. I've recreated the jlink portion of patch with this
3153 new state table. His changes to my state table are pretty minor in
3154 terms of total transitions, but Peter feels that his version fixes
3155 some long-standing problems.
3156 Jeff
3157
3158 I added the bit count into the table, reduced RESET column to 7 bits from 8.
3159 Dick
3160
3161 state specific comments:
3162 ------------------------
3163 *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to
3164 work better on ARM9 with ft2232 driver. (Dick)
3165
3166 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3167 needed on ARM9 with ft2232 driver. (Dick)
3168
3169 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3170 needed on ARM9 with ft2232 driver. (Dick)
3171 */
3172
3173 /* to state: */
3174 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3175 { B8(1111111,7), B8(0,1), B8(00101,5), B8(01010,5), B8(001101,6), B8(010110,6) }, /* RESET */
3176 { B8(1111111,7), B8(0,1), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3177 { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3178 { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3179 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3180 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3181
3182 #else /* this is the old table, converted from hex and with the bit_count set to 7 for each combo, like before */
3183
3184 /* to state: */
3185 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3186 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3187 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3188 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3189 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3190 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3191 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0100000,7), B8(0101111,7) } /* IRPAUSE */
3192
3193 #endif
3194
3195 #if 0 /* keeping old hex stuff for awhile, for reference */
3196 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
3197 { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */
3198 { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */
3199 { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */
3200 { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */
3201 { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */
3202 { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */
3203 #endif
3204 };
3205
3206
3207 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3208 {
3209 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bits;
3210 }
3211
3212
3213 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
3214 {
3215 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
3216 }
3217
3218
3219 bool tap_is_state_stable(tap_state_t astate)
3220 {
3221 bool is_stable;
3222
3223 /* A switch() is used because it is symbol dependent
3224 (not value dependent like an array), and can also check bounds.
3225 */
3226 switch( astate )
3227 {
3228 case TAP_RESET:
3229 case TAP_IDLE:
3230 case TAP_DRSHIFT:
3231 case TAP_DRPAUSE:
3232 case TAP_IRSHIFT:
3233 case TAP_IRPAUSE:
3234 is_stable = true;
3235 break;
3236 default:
3237 is_stable = false;
3238 }
3239
3240 return is_stable;
3241 }
3242
3243 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3244 {
3245 tap_state_t new_state;
3246
3247 /* A switch is used because it is symbol dependent and not value dependent
3248 like an array. Also it can check for out of range conditions.
3249 */
3250
3251 if (tms)
3252 {
3253 switch (cur_state)
3254 {
3255 case TAP_RESET:
3256 new_state = cur_state;
3257 break;
3258 case TAP_IDLE:
3259 case TAP_DRUPDATE:
3260 case TAP_IRUPDATE:
3261 new_state = TAP_DRSELECT;
3262 break;
3263 case TAP_DRSELECT:
3264 new_state = TAP_IRSELECT;
3265 break;
3266 case TAP_DRCAPTURE:
3267 case TAP_DRSHIFT:
3268 new_state = TAP_DREXIT1;
3269 break;
3270 case TAP_DREXIT1:
3271 case TAP_DREXIT2:
3272 new_state = TAP_DRUPDATE;
3273 break;
3274 case TAP_DRPAUSE:
3275 new_state = TAP_DREXIT2;
3276 break;
3277 case TAP_IRSELECT:
3278 new_state = TAP_RESET;
3279 break;
3280 case TAP_IRCAPTURE:
3281 case TAP_IRSHIFT:
3282 new_state = TAP_IREXIT1;
3283 break;
3284 case TAP_IREXIT1:
3285 case TAP_IREXIT2:
3286 new_state = TAP_IRUPDATE;
3287 break;
3288 case TAP_IRPAUSE:
3289 new_state = TAP_IREXIT2;
3290 break;
3291 default:
3292 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3293 exit(1);
3294 break;
3295 }
3296 }
3297 else
3298 {
3299 switch (cur_state)
3300 {
3301 case TAP_RESET:
3302 case TAP_IDLE:
3303 case TAP_DRUPDATE:
3304 case TAP_IRUPDATE:
3305 new_state = TAP_IDLE;
3306 break;
3307 case TAP_DRSELECT:
3308 new_state = TAP_DRCAPTURE;
3309 break;
3310 case TAP_DRCAPTURE:
3311 case TAP_DRSHIFT:
3312 case TAP_DREXIT2:
3313 new_state = TAP_DRSHIFT;
3314 break;
3315 case TAP_DREXIT1:
3316 case TAP_DRPAUSE:
3317 new_state = TAP_DRPAUSE;
3318 break;
3319 case TAP_IRSELECT:
3320 new_state = TAP_IRCAPTURE;
3321 break;
3322 case TAP_IRCAPTURE:
3323 case TAP_IRSHIFT:
3324 case TAP_IREXIT2:
3325 new_state = TAP_IRSHIFT;
3326 break;
3327 case TAP_IREXIT1:
3328 case TAP_IRPAUSE:
3329 new_state = TAP_IRPAUSE;
3330 break;
3331 default:
3332 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3333 exit(1);
3334 break;
3335 }
3336 }
3337
3338 return new_state;
3339 }
3340
3341 const char* tap_state_name(tap_state_t state)
3342 {
3343 const char* ret;
3344
3345 switch( state )
3346 {
3347 case TAP_RESET: ret = "RESET"; break;
3348 case TAP_IDLE: ret = "RUN/IDLE"; break;
3349 case TAP_DRSELECT: ret = "DRSELECT"; break;
3350 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
3351 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
3352 case TAP_DREXIT1: ret = "DREXIT1"; break;
3353 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
3354 case TAP_DREXIT2: ret = "DREXIT2"; break;
3355 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
3356 case TAP_IRSELECT: ret = "IRSELECT"; break;
3357 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3358 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3359 case TAP_IREXIT1: ret = "IREXIT1"; break;
3360 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3361 case TAP_IREXIT2: ret = "IREXIT2"; break;
3362 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3363 default: ret = "???";
3364 }
3365
3366 return ret;
3367 }
3368
3369 static tap_state_t tap_state_by_name( const char *name )
3370 {
3371 tap_state_t x;
3372
3373 for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3374 /* be nice to the human */
3375 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3376 return x;
3377 }
3378 }
3379 /* not found */
3380 return TAP_INVALID;
3381 }
3382
3383 #ifdef _DEBUG_JTAG_IO_
3384
3385 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3386 do { buf[len] = bit ? '1' : '0'; } while(0)
3387 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3388 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3389 tap_state_name(a), tap_state_name(b), astr, bstr)
3390
3391 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3392 unsigned tap_bits, tap_state_t next_state)
3393 {
3394 const u8 *tms_buffer;
3395 const u8 *tdi_buffer;
3396 unsigned tap_bytes;
3397 unsigned cur_byte;
3398 unsigned cur_bit;
3399
3400 unsigned tap_out_bits;
3401 char tms_str[33];
3402 char tdi_str[33];
3403
3404 tap_state_t last_state;
3405
3406 // set startstate (and possibly last, if tap_bits == 0)
3407 last_state = next_state;
3408 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3409
3410 tms_buffer = (const u8 *)tms_buf;
3411 tdi_buffer = (const u8 *)tdi_buf;
3412
3413 tap_bytes = TAP_SCAN_BYTES(tap_bits);
3414 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3415
3416 tap_out_bits = 0;
3417 for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3418 {
3419 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3420 {
3421 // make sure we do not run off the end of the buffers
3422 unsigned tap_bit = cur_byte * 8 + cur_bit;
3423 if (tap_bit == tap_bits)
3424 break;
3425
3426 // check and save TMS bit
3427 tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3428 JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3429
3430 // use TMS bit to find the next TAP state
3431 next_state = tap_state_transition(last_state, tap_bit);
3432
3433 // check and store TDI bit
3434 tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3435 JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3436
3437 // increment TAP bits
3438 tap_out_bits++;
3439
3440 // Only show TDO bits on state transitions, or
3441 // after some number of bits in the same state.
3442 if ((next_state == last_state) && (tap_out_bits < 32))
3443 continue;
3444
3445 // terminate strings and display state transition
3446 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3447 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3448
3449 // reset state
3450 last_state = next_state;
3451 tap_out_bits = 0;
3452 }
3453 }
3454
3455 if (tap_out_bits)
3456 {
3457 // terminate strings and display state transition
3458 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3459 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3460 }
3461
3462 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3463
3464 return next_state;
3465 }
3466 #endif // _DEBUG_JTAG_IO_
3467
3468 /*-----</Cable Helper API>--------------------------------------*/
Open On-Chip Debugger

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)