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