Code Review / openocd.git / blob
? search:


c665ba206f517eab63aac7f9a40fcfad033e586c
[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 if ( tap_state_transition(cur_state, true) != path[i]
960 && tap_state_transition(cur_state, false) != path[i])
961 {
962 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
963 exit(-1);
964 }
965 cur_state = path[i];
966 }
967
968 jtag_prelude1();
969
970 retval=interface_jtag_add_pathmove(num_states, path);
971 cmd_queue_cur_state = path[num_states - 1];
972 if (retval!=ERROR_OK)
973 jtag_error=retval;
974 }
975
976 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path)
977 {
978 jtag_command_t **last_cmd = jtag_get_last_command_p();
979 int i;
980
981 /* allocate memory for a new list member */
982 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
983 last_comand_pointer = &((*last_cmd)->next);
984 (*last_cmd)->next = NULL;
985 (*last_cmd)->type = JTAG_PATHMOVE;
986
987 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
988 (*last_cmd)->cmd.pathmove->num_states = num_states;
989 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
990
991 for (i = 0; i < num_states; i++)
992 (*last_cmd)->cmd.pathmove->path[i] = path[i];
993
994 return ERROR_OK;
995 }
996
997 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
998 {
999 jtag_command_t **last_cmd = jtag_get_last_command_p();
1000
1001 /* allocate memory for a new list member */
1002 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1003 (*last_cmd)->next = NULL;
1004 last_comand_pointer = &((*last_cmd)->next);
1005 (*last_cmd)->type = JTAG_RUNTEST;
1006
1007 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1008 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
1009 (*last_cmd)->cmd.runtest->end_state = state;
1010
1011 return ERROR_OK;
1012 }
1013
1014 void jtag_add_runtest(int num_cycles, tap_state_t state)
1015 {
1016 int retval;
1017
1018 jtag_prelude(state);
1019
1020 /* executed by sw or hw fifo */
1021 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1022 if (retval!=ERROR_OK)
1023 jtag_error=retval;
1024 }
1025
1026
1027 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1028 {
1029 jtag_command_t **last_cmd = jtag_get_last_command_p();
1030
1031 /* allocate memory for a new list member */
1032 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1033 (*last_cmd)->next = NULL;
1034 last_comand_pointer = &((*last_cmd)->next);
1035 (*last_cmd)->type = JTAG_STABLECLOCKS;
1036
1037 (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1038 (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles;
1039 return ERROR_OK;
1040 }
1041
1042 void jtag_add_clocks( int num_cycles )
1043 {
1044 int retval;
1045
1046 if( !tap_is_state_stable(cmd_queue_cur_state) )
1047 {
1048 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1049 tap_state_name(cmd_queue_cur_state) );
1050 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1051 return;
1052 }
1053
1054 if( num_cycles > 0 )
1055 {
1056 jtag_prelude1();
1057
1058 retval = interface_jtag_add_clocks(num_cycles);
1059 if (retval != ERROR_OK)
1060 jtag_error=retval;
1061 }
1062 }
1063
1064 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1065 {
1066 int trst_with_tlr = 0;
1067 int retval;
1068
1069 /* FIX!!! there are *many* different cases here. A better
1070 * approach is needed for legal combinations of transitions...
1071 */
1072 if ((jtag_reset_config & RESET_HAS_SRST)&&
1073 (jtag_reset_config & RESET_HAS_TRST)&&
1074 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1075 {
1076 if (((req_tlr_or_trst&&!jtag_trst)||
1077 (!req_tlr_or_trst&&jtag_trst))&&
1078 ((req_srst&&!jtag_srst)||
1079 (!req_srst&&jtag_srst)))
1080 {
1081 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1082 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1083 }
1084 }
1085
1086 /* Make sure that jtag_reset_config allows the requested reset */
1087 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1088 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1089 {
1090 LOG_ERROR("BUG: requested reset would assert trst");
1091 jtag_error=ERROR_FAIL;
1092 return;
1093 }
1094
1095 /* if TRST pulls SRST, we reset with TAP T-L-R */
1096 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1097 {
1098 trst_with_tlr = 1;
1099 }
1100
1101 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1102 {
1103 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1104 jtag_error=ERROR_FAIL;
1105 return;
1106 }
1107
1108 if (req_tlr_or_trst)
1109 {
1110 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1111 {
1112 jtag_trst = 1;
1113 } else
1114 {
1115 trst_with_tlr = 1;
1116 }
1117 } else
1118 {
1119 jtag_trst = 0;
1120 }
1121
1122 jtag_srst = req_srst;
1123
1124 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1125 if (retval!=ERROR_OK)
1126 {
1127 jtag_error=retval;
1128 return;
1129 }
1130
1131 if (jtag_srst)
1132 {
1133 LOG_DEBUG("SRST line asserted");
1134 }
1135 else
1136 {
1137 LOG_DEBUG("SRST line released");
1138 if (jtag_nsrst_delay)
1139 jtag_add_sleep(jtag_nsrst_delay * 1000);
1140 }
1141
1142 if (trst_with_tlr)
1143 {
1144 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1145 jtag_add_end_state(TAP_RESET);
1146 jtag_add_tlr();
1147 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1148 return;
1149 }
1150
1151 if (jtag_trst)
1152 {
1153 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1154 * and inform possible listeners about this
1155 */
1156 LOG_DEBUG("TRST line asserted");
1157 cmd_queue_cur_state = TAP_RESET;
1158 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1159 }
1160 else
1161 {
1162 if (jtag_ntrst_delay)
1163 jtag_add_sleep(jtag_ntrst_delay * 1000);
1164 }
1165 }
1166
1167 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1168 {
1169 jtag_command_t **last_cmd = jtag_get_last_command_p();
1170
1171 /* allocate memory for a new list member */
1172 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1173 (*last_cmd)->next = NULL;
1174 last_comand_pointer = &((*last_cmd)->next);
1175 (*last_cmd)->type = JTAG_RESET;
1176
1177 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1178 (*last_cmd)->cmd.reset->trst = req_trst;
1179 (*last_cmd)->cmd.reset->srst = req_srst;
1180
1181 return ERROR_OK;
1182 }
1183
1184 void jtag_add_end_state(tap_state_t state)
1185 {
1186 cmd_queue_end_state = state;
1187 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1188 {
1189 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1190 }
1191 }
1192
1193 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1194 {
1195 jtag_command_t **last_cmd = jtag_get_last_command_p();
1196
1197 /* allocate memory for a new list member */
1198 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1199 (*last_cmd)->next = NULL;
1200 last_comand_pointer = &((*last_cmd)->next);
1201 (*last_cmd)->type = JTAG_SLEEP;
1202
1203 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1204 (*last_cmd)->cmd.sleep->us = us;
1205
1206 return ERROR_OK;
1207 }
1208
1209 void jtag_add_sleep(u32 us)
1210 {
1211 keep_alive(); /* we might be running on a very slow JTAG clk */
1212 int retval=interface_jtag_add_sleep(us);
1213 if (retval!=ERROR_OK)
1214 jtag_error=retval;
1215 return;
1216 }
1217
1218 int jtag_scan_size(scan_command_t *cmd)
1219 {
1220 int bit_count = 0;
1221 int i;
1222
1223 /* count bits in scan command */
1224 for (i = 0; i < cmd->num_fields; i++)
1225 {
1226 bit_count += cmd->fields[i].num_bits;
1227 }
1228
1229 return bit_count;
1230 }
1231
1232 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1233 {
1234 int bit_count = 0;
1235 int i;
1236
1237 bit_count = jtag_scan_size(cmd);
1238 *buffer = malloc(CEIL(bit_count, 8));
1239
1240 bit_count = 0;
1241
1242 #ifdef _DEBUG_JTAG_IO_
1243 LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
1244 #endif
1245
1246 for (i = 0; i < cmd->num_fields; i++)
1247 {
1248 if (cmd->fields[i].out_value)
1249 {
1250 #ifdef _DEBUG_JTAG_IO_
1251 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);
1252 #endif
1253 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1254 #ifdef _DEBUG_JTAG_IO_
1255 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1256 free(char_buf);
1257 #endif
1258 }
1259 else
1260 {
1261 #ifdef _DEBUG_JTAG_IO_
1262 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
1263 #endif
1264 }
1265
1266 bit_count += cmd->fields[i].num_bits;
1267 }
1268
1269 #ifdef _DEBUG_JTAG_IO_
1270 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1271 #endif
1272
1273 return bit_count;
1274 }
1275
1276 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1277 {
1278 int i;
1279 int bit_count = 0;
1280 int retval;
1281
1282 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1283 retval = ERROR_OK;
1284
1285 for (i = 0; i < cmd->num_fields; i++)
1286 {
1287 /* if neither in_value nor in_handler
1288 * are specified we don't have to examine this field
1289 */
1290 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1291 {
1292 int num_bits = cmd->fields[i].num_bits;
1293 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1294
1295 #ifdef _DEBUG_JTAG_IO_
1296 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1297 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1298 free(char_buf);
1299 #endif
1300
1301 if (cmd->fields[i].in_value)
1302 {
1303 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1304
1305 if (cmd->fields[i].in_handler)
1306 {
1307 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1308 {
1309 LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1310 retval = ERROR_JTAG_QUEUE_FAILED;
1311 }
1312 }
1313 }
1314
1315 /* no in_value specified, but a handler takes care of the scanned data */
1316 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1317 {
1318 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1319 {
1320 /* We're going to call the error:handler later, but if the in_handler
1321 * reported an error we report this failure upstream
1322 */
1323 LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1324 retval = ERROR_JTAG_QUEUE_FAILED;
1325 }
1326 }
1327
1328 free(captured);
1329 }
1330 bit_count += cmd->fields[i].num_bits;
1331 }
1332
1333 return retval;
1334 }
1335
1336 static const char *jtag_tap_name(jtag_tap_t *tap)
1337 {
1338 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1339 }
1340
1341 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1342 {
1343 int retval = ERROR_OK;
1344 int num_bits = field->num_bits;
1345
1346 int compare_failed = 0;
1347
1348 if (field->in_check_mask)
1349 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1350 else
1351 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1352
1353 if (compare_failed){
1354 /* An error handler could have caught the failing check
1355 * only report a problem when there wasn't a handler, or if the handler
1356 * acknowledged the error
1357 */
1358 LOG_WARNING("TAP %s:",
1359 jtag_tap_name(field->tap));
1360 if (compare_failed)
1361 {
1362 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1363 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1364
1365 if (field->in_check_mask)
1366 {
1367 char *in_check_mask_char;
1368 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1369 LOG_WARNING("value captured during scan didn't pass the requested check:");
1370 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1371 captured_char, in_check_value_char, in_check_mask_char);
1372 free(in_check_mask_char);
1373 }
1374 else
1375 {
1376 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);
1377 }
1378
1379 free(captured_char);
1380 free(in_check_value_char);
1381
1382 retval = ERROR_JTAG_QUEUE_FAILED;
1383 }
1384
1385 }
1386 return retval;
1387 }
1388
1389 /*
1390 set up checking of this field using the in_handler. The values passed in must be valid until
1391 after jtag_execute() has completed.
1392 */
1393 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1394 {
1395 if (value)
1396 field->in_handler = jtag_check_value;
1397 else
1398 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1399 field->in_handler_priv = NULL;
1400 field->in_check_value = value;
1401 field->in_check_mask = mask;
1402 }
1403
1404 enum scan_type jtag_scan_type(scan_command_t *cmd)
1405 {
1406 int i;
1407 int type = 0;
1408
1409 for (i = 0; i < cmd->num_fields; i++)
1410 {
1411 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1412 type |= SCAN_IN;
1413 if (cmd->fields[i].out_value)
1414 type |= SCAN_OUT;
1415 }
1416
1417 return type;
1418 }
1419
1420 int MINIDRIVER(interface_jtag_execute_queue)(void)
1421 {
1422 int retval;
1423
1424 if (jtag==NULL)
1425 {
1426 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1427 return ERROR_FAIL;
1428 }
1429
1430 retval = jtag->execute_queue();
1431
1432 cmd_queue_free();
1433
1434 jtag_command_queue = NULL;
1435 last_comand_pointer = &jtag_command_queue;
1436
1437 return retval;
1438 }
1439
1440 int jtag_execute_queue(void)
1441 {
1442 int retval=interface_jtag_execute_queue();
1443 if (retval==ERROR_OK)
1444 {
1445 retval=jtag_error;
1446 }
1447 jtag_error=ERROR_OK;
1448 return retval;
1449 }
1450
1451 int jtag_reset_callback(enum jtag_event event, void *priv)
1452 {
1453 jtag_tap_t *tap = priv;
1454
1455 LOG_DEBUG("-");
1456
1457 if (event == JTAG_TRST_ASSERTED)
1458 {
1459 buf_set_ones(tap->cur_instr, tap->ir_length);
1460 tap->bypass = 1;
1461 }
1462
1463 return ERROR_OK;
1464 }
1465
1466 void jtag_sleep(u32 us)
1467 {
1468 alive_sleep(us/1000);
1469 }
1470
1471 /* Try to examine chain layout according to IEEE 1149.1 §12
1472 */
1473 int jtag_examine_chain(void)
1474 {
1475 jtag_tap_t *tap;
1476 scan_field_t field;
1477 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1478 int i;
1479 int bit_count;
1480 int device_count = 0;
1481 u8 zero_check = 0x0;
1482 u8 one_check = 0xff;
1483
1484 field.tap = NULL;
1485 field.num_bits = sizeof(idcode_buffer) * 8;
1486 field.out_value = idcode_buffer;
1487
1488 field.in_value = idcode_buffer;
1489 field.in_check_value = NULL;
1490 field.in_check_mask = NULL;
1491 field.in_handler = NULL;
1492 field.in_handler_priv = 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 field.in_check_value = NULL;
1668 field.in_check_mask = NULL;
1669 field.in_handler = NULL;
1670 field.in_handler_priv = NULL;
1671
1672 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1673 jtag_execute_queue();
1674
1675 tap = NULL;
1676 chain_pos = 0;
1677 int val;
1678 for(;;){
1679 tap = jtag_NextEnabledTap(tap);
1680 if( tap == NULL ){
1681 break;
1682 }
1683
1684 val = buf_get_u32(ir_test, chain_pos, 2);
1685 if (val != 0x1)
1686 {
1687 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1688 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);
1689 free(cbuf);
1690 free(ir_test);
1691 return ERROR_JTAG_INIT_FAILED;
1692 }
1693 chain_pos += tap->ir_length;
1694 }
1695
1696 val = buf_get_u32(ir_test, chain_pos, 2);
1697 if (val != 0x3)
1698 {
1699 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1700 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);
1701 free(cbuf);
1702 free(ir_test);
1703 return ERROR_JTAG_INIT_FAILED;
1704 }
1705
1706 free(ir_test);
1707
1708 return ERROR_OK;
1709 }
1710
1711 enum jtag_tap_cfg_param {
1712 JCFG_EVENT
1713 };
1714
1715 static Jim_Nvp nvp_config_opts[] = {
1716 { .name = "-event", .value = JCFG_EVENT },
1717
1718 { .name = NULL, .value = -1 }
1719 };
1720
1721 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1722 {
1723 Jim_Nvp *n;
1724 Jim_Obj *o;
1725 int e;
1726
1727 /* parse config or cget options */
1728 while (goi->argc > 0) {
1729 Jim_SetEmptyResult (goi->interp);
1730
1731 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1732 if (e != JIM_OK) {
1733 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1734 return e;
1735 }
1736
1737 switch (n->value) {
1738 case JCFG_EVENT:
1739 if (goi->argc == 0) {
1740 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1741 return JIM_ERR;
1742 }
1743
1744 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1745 if (e != JIM_OK) {
1746 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1747 return e;
1748 }
1749
1750 if (goi->isconfigure) {
1751 if (goi->argc != 1) {
1752 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1753 return JIM_ERR;
1754 }
1755 } else {
1756 if (goi->argc != 0) {
1757 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1758 return JIM_ERR;
1759 }
1760 }
1761
1762 {
1763 jtag_tap_event_action_t *jteap;
1764
1765 jteap = tap->event_action;
1766 /* replace existing? */
1767 while (jteap) {
1768 if (jteap->event == (enum jtag_tap_event)n->value) {
1769 break;
1770 }
1771 jteap = jteap->next;
1772 }
1773
1774 if (goi->isconfigure) {
1775 if (jteap == NULL) {
1776 /* create new */
1777 jteap = calloc(1, sizeof (*jteap));
1778 }
1779 jteap->event = n->value;
1780 Jim_GetOpt_Obj( goi, &o);
1781 if (jteap->body) {
1782 Jim_DecrRefCount(interp, jteap->body);
1783 }
1784 jteap->body = Jim_DuplicateObj(goi->interp, o);
1785 Jim_IncrRefCount(jteap->body);
1786
1787 /* add to head of event list */
1788 jteap->next = tap->event_action;
1789 tap->event_action = jteap;
1790 Jim_SetEmptyResult(goi->interp);
1791 } else {
1792 /* get */
1793 if (jteap == NULL) {
1794 Jim_SetEmptyResult(goi->interp);
1795 } else {
1796 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1797 }
1798 }
1799 }
1800 /* loop for more */
1801 break;
1802 }
1803 } /* while (goi->argc) */
1804
1805 return JIM_OK;
1806 }
1807
1808 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1809 {
1810 jtag_tap_t *pTap;
1811 jtag_tap_t **ppTap;
1812 jim_wide w;
1813 int x;
1814 int e;
1815 int reqbits;
1816 Jim_Nvp *n;
1817 char *cp;
1818 const Jim_Nvp opts[] = {
1819 #define NTAP_OPT_IRLEN 0
1820 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1821 #define NTAP_OPT_IRMASK 1
1822 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1823 #define NTAP_OPT_IRCAPTURE 2
1824 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1825 #define NTAP_OPT_ENABLED 3
1826 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1827 #define NTAP_OPT_DISABLED 4
1828 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1829 #define NTAP_OPT_EXPECTED_ID 5
1830 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1831 { .name = NULL , .value = -1 },
1832 };
1833
1834 pTap = malloc( sizeof(jtag_tap_t) );
1835 memset( pTap, 0, sizeof(*pTap) );
1836 if( !pTap ){
1837 Jim_SetResult_sprintf( goi->interp, "no memory");
1838 return JIM_ERR;
1839 }
1840 /*
1841 * we expect CHIP + TAP + OPTIONS
1842 * */
1843 if( goi->argc < 3 ){
1844 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1845 return JIM_ERR;
1846 }
1847 Jim_GetOpt_String( goi, &cp, NULL );
1848 pTap->chip = strdup(cp);
1849
1850 Jim_GetOpt_String( goi, &cp, NULL );
1851 pTap->tapname = strdup(cp);
1852
1853 /* name + dot + name + null */
1854 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1855 cp = malloc( x );
1856 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1857 pTap->dotted_name = cp;
1858
1859 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1860 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1861
1862 /* default is enabled */
1863 pTap->enabled = 1;
1864
1865 /* deal with options */
1866 #define NTREQ_IRLEN 1
1867 #define NTREQ_IRCAPTURE 2
1868 #define NTREQ_IRMASK 4
1869
1870 /* clear them as we find them */
1871 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1872
1873 while( goi->argc ){
1874 e = Jim_GetOpt_Nvp( goi, opts, &n );
1875 if( e != JIM_OK ){
1876 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1877 return e;
1878 }
1879 LOG_DEBUG("Processing option: %s", n->name );
1880 switch( n->value ){
1881 case NTAP_OPT_ENABLED:
1882 pTap->enabled = 1;
1883 break;
1884 case NTAP_OPT_DISABLED:
1885 pTap->enabled = 0;
1886 break;
1887 case NTAP_OPT_EXPECTED_ID:
1888 {
1889 u32 *new_expected_ids;
1890
1891 e = Jim_GetOpt_Wide( goi, &w );
1892 if( e != JIM_OK) {
1893 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1894 return e;
1895 }
1896
1897 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1898 if (new_expected_ids == NULL) {
1899 Jim_SetResult_sprintf( goi->interp, "no memory");
1900 return JIM_ERR;
1901 }
1902
1903 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1904
1905 new_expected_ids[pTap->expected_ids_cnt] = w;
1906
1907 free(pTap->expected_ids);
1908 pTap->expected_ids = new_expected_ids;
1909 pTap->expected_ids_cnt++;
1910 break;
1911 }
1912 case NTAP_OPT_IRLEN:
1913 case NTAP_OPT_IRMASK:
1914 case NTAP_OPT_IRCAPTURE:
1915 e = Jim_GetOpt_Wide( goi, &w );
1916 if( e != JIM_OK ){
1917 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1918 return e;
1919 }
1920 if( (w < 0) || (w > 0xffff) ){
1921 /* wacky value */
1922 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1923 n->name, (int)(w), (int)(w));
1924 return JIM_ERR;
1925 }
1926 switch(n->value){
1927 case NTAP_OPT_IRLEN:
1928 pTap->ir_length = w;
1929 reqbits &= (~(NTREQ_IRLEN));
1930 break;
1931 case NTAP_OPT_IRMASK:
1932 pTap->ir_capture_mask = w;
1933 reqbits &= (~(NTREQ_IRMASK));
1934 break;
1935 case NTAP_OPT_IRCAPTURE:
1936 pTap->ir_capture_value = w;
1937 reqbits &= (~(NTREQ_IRCAPTURE));
1938 break;
1939 }
1940 } /* switch(n->value) */
1941 } /* while( goi->argc ) */
1942
1943 /* Did we get all the options? */
1944 if( reqbits ){
1945 // no
1946 Jim_SetResult_sprintf( goi->interp,
1947 "newtap: %s missing required parameters",
1948 pTap->dotted_name);
1949 /* TODO: Tell user what is missing :-( */
1950 /* no memory leaks pelase */
1951 free(((void *)(pTap->expected_ids)));
1952 free(((void *)(pTap->chip)));
1953 free(((void *)(pTap->tapname)));
1954 free(((void *)(pTap->dotted_name)));
1955 free(((void *)(pTap)));
1956 return JIM_ERR;
1957 }
1958
1959 pTap->expected = malloc( pTap->ir_length );
1960 pTap->expected_mask = malloc( pTap->ir_length );
1961 pTap->cur_instr = malloc( pTap->ir_length );
1962
1963 buf_set_u32( pTap->expected,
1964 0,
1965 pTap->ir_length,
1966 pTap->ir_capture_value );
1967 buf_set_u32( pTap->expected_mask,
1968 0,
1969 pTap->ir_length,
1970 pTap->ir_capture_mask );
1971 buf_set_ones( pTap->cur_instr,
1972 pTap->ir_length );
1973
1974 pTap->bypass = 1;
1975
1976 jtag_register_event_callback(jtag_reset_callback, pTap );
1977
1978 ppTap = &(jtag_all_taps);
1979 while( (*ppTap) != NULL ){
1980 ppTap = &((*ppTap)->next_tap);
1981 }
1982 *ppTap = pTap;
1983 {
1984 static int n_taps = 0;
1985 pTap->abs_chain_position = n_taps++;
1986 }
1987 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1988 (*ppTap)->dotted_name,
1989 (*ppTap)->abs_chain_position,
1990 (*ppTap)->ir_length,
1991 (*ppTap)->ir_capture_value,
1992 (*ppTap)->ir_capture_mask );
1993
1994 return ERROR_OK;
1995 }
1996
1997 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
1998 {
1999 Jim_GetOptInfo goi;
2000 int e;
2001 Jim_Nvp *n;
2002 Jim_Obj *o;
2003 struct command_context_s *context;
2004
2005 enum {
2006 JTAG_CMD_INTERFACE,
2007 JTAG_CMD_INIT_RESET,
2008 JTAG_CMD_NEWTAP,
2009 JTAG_CMD_TAPENABLE,
2010 JTAG_CMD_TAPDISABLE,
2011 JTAG_CMD_TAPISENABLED,
2012 JTAG_CMD_CONFIGURE,
2013 JTAG_CMD_CGET
2014 };
2015
2016 const Jim_Nvp jtag_cmds[] = {
2017 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2018 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2019 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2020 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2021 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2022 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2023 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2024 { .name = "cget" , .value = JTAG_CMD_CGET },
2025
2026 { .name = NULL, .value = -1 },
2027 };
2028
2029 context = Jim_GetAssocData(interp, "context");
2030 /* go past the command */
2031 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2032
2033 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2034 if( e != JIM_OK ){
2035 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2036 return e;
2037 }
2038 Jim_SetEmptyResult( goi.interp );
2039 switch( n->value ){
2040 case JTAG_CMD_INTERFACE:
2041 /* return the name of the interface */
2042 /* TCL code might need to know the exact type... */
2043 /* FUTURE: we allow this as a means to "set" the interface. */
2044 if( goi.argc != 0 ){
2045 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2046 return JIM_ERR;
2047 }
2048 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2049 return JIM_OK;
2050 case JTAG_CMD_INIT_RESET:
2051 if( goi.argc != 0 ){
2052 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2053 return JIM_ERR;
2054 }
2055 e = jtag_init_reset(context);
2056 if( e != ERROR_OK ){
2057 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2058 return JIM_ERR;
2059 }
2060 return JIM_OK;
2061 case JTAG_CMD_NEWTAP:
2062 return jim_newtap_cmd( &goi );
2063 break;
2064 case JTAG_CMD_TAPISENABLED:
2065 case JTAG_CMD_TAPENABLE:
2066 case JTAG_CMD_TAPDISABLE:
2067 if( goi.argc != 1 ){
2068 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2069 return JIM_ERR;
2070 }
2071
2072 {
2073 jtag_tap_t *t;
2074 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2075 if( t == NULL ){
2076 return JIM_ERR;
2077 }
2078 switch( n->value ){
2079 case JTAG_CMD_TAPISENABLED:
2080 e = t->enabled;
2081 break;
2082 case JTAG_CMD_TAPENABLE:
2083 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2084 e = 1;
2085 t->enabled = e;
2086 break;
2087 case JTAG_CMD_TAPDISABLE:
2088 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2089 e = 0;
2090 t->enabled = e;
2091 break;
2092 }
2093 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2094 return JIM_OK;
2095 }
2096 break;
2097
2098 case JTAG_CMD_CGET:
2099 if( goi.argc < 2 ){
2100 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2101 return JIM_ERR;
2102 }
2103
2104 {
2105 jtag_tap_t *t;
2106
2107 Jim_GetOpt_Obj(&goi, &o);
2108 t = jtag_TapByJimObj( goi.interp, o );
2109 if( t == NULL ){
2110 return JIM_ERR;
2111 }
2112
2113 goi.isconfigure = 0;
2114 return jtag_tap_configure_cmd( &goi, t);
2115 }
2116 break;
2117
2118 case JTAG_CMD_CONFIGURE:
2119 if( goi.argc < 3 ){
2120 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2121 return JIM_ERR;
2122 }
2123
2124 {
2125 jtag_tap_t *t;
2126
2127 Jim_GetOpt_Obj(&goi, &o);
2128 t = jtag_TapByJimObj( goi.interp, o );
2129 if( t == NULL ){
2130 return JIM_ERR;
2131 }
2132
2133 goi.isconfigure = 1;
2134 return jtag_tap_configure_cmd( &goi, t);
2135 }
2136 }
2137
2138 return JIM_ERR;
2139 }
2140
2141 int jtag_register_commands(struct command_context_s *cmd_ctx)
2142 {
2143 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2144
2145 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2146 COMMAND_CONFIG, "try to configure interface");
2147 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2148 COMMAND_ANY, "set jtag speed (if supported)");
2149 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2150 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2151 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2152 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2153 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2154 COMMAND_ANY,
2155 "[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]");
2156 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2157 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2158 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2159 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2160
2161 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2162 COMMAND_EXEC, "print current scan chain configuration");
2163
2164 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2165 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2166 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2167 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2168 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2169 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2170 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2171 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2172 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2173
2174 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2175 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2176 return ERROR_OK;
2177 }
2178
2179 int jtag_interface_init(struct command_context_s *cmd_ctx)
2180 {
2181 if (jtag)
2182 return ERROR_OK;
2183
2184 if (!jtag_interface)
2185 {
2186 /* nothing was previously specified by "interface" command */
2187 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2188 return ERROR_JTAG_INVALID_INTERFACE;
2189 }
2190 if(hasKHz)
2191 {
2192 jtag_interface->khz(speed_khz, &jtag_speed);
2193 hasKHz = 0;
2194 }
2195
2196 if (jtag_interface->init() != ERROR_OK)
2197 return ERROR_JTAG_INIT_FAILED;
2198
2199 jtag = jtag_interface;
2200 return ERROR_OK;
2201 }
2202
2203 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2204 {
2205 jtag_tap_t *tap;
2206 int retval;
2207
2208 LOG_DEBUG("Init JTAG chain");
2209
2210 tap = jtag_NextEnabledTap(NULL);
2211 if( tap == NULL ){
2212 LOG_ERROR("There are no enabled taps?");
2213 return ERROR_JTAG_INIT_FAILED;
2214 }
2215
2216 jtag_add_tlr();
2217 if ((retval=jtag_execute_queue())!=ERROR_OK)
2218 return retval;
2219
2220 /* examine chain first, as this could discover the real chain layout */
2221 if (jtag_examine_chain() != ERROR_OK)
2222 {
2223 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2224 }
2225
2226 if (jtag_validate_chain() != ERROR_OK)
2227 {
2228 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2229 }
2230
2231 return ERROR_OK;
2232 }
2233
2234 int jtag_init_reset(struct command_context_s *cmd_ctx)
2235 {
2236 int retval;
2237
2238 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2239 return retval;
2240
2241 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2242
2243 /* Reset can happen after a power cycle.
2244 *
2245 * Ideally we would only assert TRST or run RESET before the target reset.
2246 *
2247 * However w/srst_pulls_trst, trst is asserted together with the target
2248 * reset whether we want it or not.
2249 *
2250 * NB! Some targets have JTAG circuitry disabled until a
2251 * trst & srst has been asserted.
2252 *
2253 * NB! here we assume nsrst/ntrst delay are sufficient!
2254 *
2255 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2256 *
2257 */
2258 jtag_add_reset(1, 0); /* RESET or TRST */
2259 if (jtag_reset_config & RESET_HAS_SRST)
2260 {
2261 jtag_add_reset(1, 1);
2262 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2263 jtag_add_reset(0, 1);
2264 }
2265 jtag_add_reset(0, 0);
2266 if ((retval = jtag_execute_queue()) != ERROR_OK)
2267 return retval;
2268
2269 /* Check that we can communication on the JTAG chain + eventually we want to
2270 * be able to perform enumeration only after OpenOCD has started
2271 * telnet and GDB server
2272 *
2273 * That would allow users to more easily perform any magic they need to before
2274 * reset happens.
2275 */
2276 return jtag_init_inner(cmd_ctx);
2277 }
2278
2279 int jtag_init(struct command_context_s *cmd_ctx)
2280 {
2281 int retval;
2282 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2283 return retval;
2284 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2285 {
2286 return ERROR_OK;
2287 }
2288 return jtag_init_reset(cmd_ctx);
2289 }
2290
2291 static int default_khz(int khz, int *jtag_speed)
2292 {
2293 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2294 return ERROR_FAIL;
2295 }
2296
2297 static int default_speed_div(int speed, int *khz)
2298 {
2299 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2300 return ERROR_FAIL;
2301 }
2302
2303 static int default_power_dropout(int *dropout)
2304 {
2305 *dropout=0; /* by default we can't detect power dropout */
2306 return ERROR_OK;
2307 }
2308
2309 static int default_srst_asserted(int *srst_asserted)
2310 {
2311 *srst_asserted=0; /* by default we can't detect srst asserted */
2312 return ERROR_OK;
2313 }
2314
2315 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2316 {
2317 int i;
2318 int retval;
2319
2320 /* check whether the interface is already configured */
2321 if (jtag_interface)
2322 {
2323 LOG_WARNING("Interface already configured, ignoring");
2324 return ERROR_OK;
2325 }
2326
2327 /* interface name is a mandatory argument */
2328 if (argc < 1 || args[0][0] == '\0')
2329 {
2330 return ERROR_COMMAND_SYNTAX_ERROR;
2331 }
2332
2333 for (i=0; jtag_interfaces[i]; i++)
2334 {
2335 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2336 {
2337 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2338 {
2339 return retval;
2340 }
2341
2342 jtag_interface = jtag_interfaces[i];
2343
2344 if (jtag_interface->khz == NULL)
2345 {
2346 jtag_interface->khz = default_khz;
2347 }
2348 if (jtag_interface->speed_div == NULL)
2349 {
2350 jtag_interface->speed_div = default_speed_div;
2351 }
2352 if (jtag_interface->power_dropout == NULL)
2353 {
2354 jtag_interface->power_dropout = default_power_dropout;
2355 }
2356 if (jtag_interface->srst_asserted == NULL)
2357 {
2358 jtag_interface->srst_asserted = default_srst_asserted;
2359 }
2360
2361 return ERROR_OK;
2362 }
2363 }
2364
2365 /* no valid interface was found (i.e. the configuration option,
2366 * didn't match one of the compiled-in interfaces
2367 */
2368 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2369 LOG_ERROR("compiled-in jtag interfaces:");
2370 for (i = 0; jtag_interfaces[i]; i++)
2371 {
2372 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2373 }
2374
2375 return ERROR_JTAG_INVALID_INTERFACE;
2376 }
2377
2378 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2379 {
2380 int e;
2381 char buf[1024];
2382 Jim_Obj *newargs[ 10 ];
2383 /*
2384 * CONVERT SYNTAX
2385 * argv[-1] = command
2386 * argv[ 0] = ir length
2387 * argv[ 1] = ir capture
2388 * argv[ 2] = ir mask
2389 * argv[ 3] = not actually used by anything but in the docs
2390 */
2391
2392 if( argc < 4 ){
2393 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2394 return ERROR_OK;
2395 }
2396 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2397 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2398 args[0],
2399 args[1],
2400 args[2] );
2401 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2402 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2403 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2404 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2405
2406 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2407 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2408 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2409 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2410 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2411 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2412 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2413 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2414 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2415 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2416 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2417 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2418
2419 command_print( cmd_ctx, "NEW COMMAND:");
2420 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2421 Jim_GetString( newargs[0], NULL ),
2422 Jim_GetString( newargs[1], NULL ),
2423 Jim_GetString( newargs[2], NULL ),
2424 Jim_GetString( newargs[3], NULL ),
2425 Jim_GetString( newargs[4], NULL ),
2426 Jim_GetString( newargs[5], NULL ),
2427 Jim_GetString( newargs[6], NULL ),
2428 Jim_GetString( newargs[7], NULL ),
2429 Jim_GetString( newargs[8], NULL ),
2430 Jim_GetString( newargs[9], NULL ) );
2431
2432 e = jim_jtag_command( interp, 10, newargs );
2433 if( e != JIM_OK ){
2434 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2435 }
2436 return e;
2437 }
2438
2439 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2440 {
2441 jtag_tap_t *tap;
2442
2443 tap = jtag_all_taps;
2444 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2445 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2446
2447 while( tap ){
2448 u32 expected, expected_mask, cur_instr, ii;
2449 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2450 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2451 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2452
2453 command_print(cmd_ctx,
2454 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2455 tap->abs_chain_position,
2456 tap->dotted_name,
2457 tap->enabled ? 'Y' : 'n',
2458 tap->idcode,
2459 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2460 tap->ir_length,
2461 expected,
2462 expected_mask,
2463 cur_instr);
2464
2465 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2466 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2467 tap->expected_ids[ii]);
2468 }
2469
2470 tap = tap->next_tap;
2471 }
2472
2473 return ERROR_OK;
2474 }
2475
2476 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2477 {
2478 if (argc < 1)
2479 return ERROR_COMMAND_SYNTAX_ERROR;
2480
2481 if (argc >= 1)
2482 {
2483 if (strcmp(args[0], "none") == 0)
2484 jtag_reset_config = RESET_NONE;
2485 else if (strcmp(args[0], "trst_only") == 0)
2486 jtag_reset_config = RESET_HAS_TRST;
2487 else if (strcmp(args[0], "srst_only") == 0)
2488 jtag_reset_config = RESET_HAS_SRST;
2489 else if (strcmp(args[0], "trst_and_srst") == 0)
2490 jtag_reset_config = RESET_TRST_AND_SRST;
2491 else
2492 {
2493 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2494 jtag_reset_config = RESET_NONE;
2495 return ERROR_INVALID_ARGUMENTS;
2496 }
2497 }
2498
2499 if (argc >= 2)
2500 {
2501 if (strcmp(args[1], "separate") == 0)
2502 {
2503 /* seperate reset lines - default */
2504 } else
2505 {
2506 if (strcmp(args[1], "srst_pulls_trst") == 0)
2507 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2508 else if (strcmp(args[1], "trst_pulls_srst") == 0)
2509 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2510 else if (strcmp(args[1], "combined") == 0)
2511 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2512 else
2513 {
2514 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2515 jtag_reset_config = RESET_NONE;
2516 return ERROR_INVALID_ARGUMENTS;
2517 }
2518 }
2519 }
2520
2521 if (argc >= 3)
2522 {
2523 if (strcmp(args[2], "trst_open_drain") == 0)
2524 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2525 else if (strcmp(args[2], "trst_push_pull") == 0)
2526 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2527 else
2528 {
2529 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2530 jtag_reset_config = RESET_NONE;
2531 return ERROR_INVALID_ARGUMENTS;
2532 }
2533 }
2534
2535 if (argc >= 4)
2536 {
2537 if (strcmp(args[3], "srst_push_pull") == 0)
2538 jtag_reset_config |= RESET_SRST_PUSH_PULL;
2539 else if (strcmp(args[3], "srst_open_drain") == 0)
2540 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2541 else
2542 {
2543 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2544 jtag_reset_config = RESET_NONE;
2545 return ERROR_INVALID_ARGUMENTS;
2546 }
2547 }
2548
2549 return ERROR_OK;
2550 }
2551
2552 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2553 {
2554 if (argc < 1)
2555 {
2556 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2557 exit(-1);
2558 }
2559 else
2560 {
2561 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2562 }
2563
2564 return ERROR_OK;
2565 }
2566
2567 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2568 {
2569 if (argc < 1)
2570 {
2571 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2572 exit(-1);
2573 }
2574 else
2575 {
2576 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2577 }
2578
2579 return ERROR_OK;
2580 }
2581
2582 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2583 {
2584 int retval=ERROR_OK;
2585
2586 if (argc == 1)
2587 {
2588 LOG_DEBUG("handle jtag speed");
2589
2590 int cur_speed = 0;
2591 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2592
2593 /* this command can be called during CONFIG,
2594 * in which case jtag isn't initialized */
2595 if (jtag)
2596 {
2597 retval=jtag->speed(cur_speed);
2598 }
2599 } else if (argc == 0)
2600 {
2601 } else
2602 {
2603 return ERROR_COMMAND_SYNTAX_ERROR;
2604 }
2605 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2606
2607 return retval;
2608 }
2609
2610 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2611 {
2612 int retval=ERROR_OK;
2613 LOG_DEBUG("handle jtag khz");
2614
2615 if(argc == 1)
2616 {
2617 speed_khz = strtoul(args[0], NULL, 0);
2618 if (jtag != NULL)
2619 {
2620 int cur_speed = 0;
2621 LOG_DEBUG("have interface set up");
2622 int speed_div1;
2623 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2624 {
2625 speed_khz = 0;
2626 return retval;
2627 }
2628
2629 cur_speed = jtag_speed = speed_div1;
2630
2631 retval=jtag->speed(cur_speed);
2632 } else
2633 {
2634 hasKHz = 1;
2635 }
2636 } else if (argc==0)
2637 {
2638 } else
2639 {
2640 return ERROR_COMMAND_SYNTAX_ERROR;
2641 }
2642
2643 if (jtag!=NULL)
2644 {
2645 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2646 return retval;
2647 }
2648
2649 if (speed_khz==0)
2650 {
2651 command_print(cmd_ctx, "RCLK - adaptive");
2652 } else
2653 {
2654 command_print(cmd_ctx, "%d kHz", speed_khz);
2655 }
2656 return retval;
2657
2658 }
2659
2660 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2661 {
2662 tap_state_t state;
2663
2664 if (argc < 1)
2665 {
2666 return ERROR_COMMAND_SYNTAX_ERROR;
2667 }
2668 else
2669 {
2670 state = tap_state_by_name( args[0] );
2671 if( state < 0 ){
2672 command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2673 return ERROR_COMMAND_SYNTAX_ERROR;
2674 }
2675 jtag_add_end_state(state);
2676 jtag_execute_queue();
2677 }
2678 command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2679
2680 return ERROR_OK;
2681 }
2682
2683 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2684 {
2685 int trst = -1;
2686 int srst = -1;
2687
2688 if (argc < 2)
2689 {
2690 return ERROR_COMMAND_SYNTAX_ERROR;
2691 }
2692
2693 if (args[0][0] == '1')
2694 trst = 1;
2695 else if (args[0][0] == '0')
2696 trst = 0;
2697 else
2698 {
2699 return ERROR_COMMAND_SYNTAX_ERROR;
2700 }
2701
2702 if (args[1][0] == '1')
2703 srst = 1;
2704 else if (args[1][0] == '0')
2705 srst = 0;
2706 else
2707 {
2708 return ERROR_COMMAND_SYNTAX_ERROR;
2709 }
2710
2711 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2712 return ERROR_JTAG_INIT_FAILED;
2713
2714 jtag_add_reset(trst, srst);
2715 jtag_execute_queue();
2716
2717 return ERROR_OK;
2718 }
2719
2720 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2721 {
2722 if (argc < 1)
2723 {
2724 return ERROR_COMMAND_SYNTAX_ERROR;
2725 }
2726
2727 jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2728 jtag_execute_queue();
2729
2730 return ERROR_OK;
2731
2732 }
2733
2734 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2735 {
2736 int i;
2737 scan_field_t *fields;
2738 jtag_tap_t *tap;
2739 tap_state_t endstate;
2740
2741 if ((argc < 2) || (argc % 2))
2742 {
2743 return ERROR_COMMAND_SYNTAX_ERROR;
2744 }
2745
2746 /* optional "-endstate" */
2747 /* "statename" */
2748 /* at the end of the arguments. */
2749 /* assume none. */
2750 endstate = TAP_INVALID;
2751 if( argc >= 4 ){
2752 /* have at least one pair of numbers. */
2753 /* is last pair the magic text? */
2754 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2755 const char *cpA;
2756 const char *cpS;
2757 cpA = args[ argc-1 ];
2758 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2759 cpS = tap_state_name( endstate );
2760 if( 0 == strcmp( cpA, cpS ) ){
2761 break;
2762 }
2763 }
2764 if( endstate >= TAP_NUM_STATES ){
2765 return ERROR_COMMAND_SYNTAX_ERROR;
2766 } else {
2767 /* found - remove the last 2 args */
2768 argc -= 2;
2769 }
2770 }
2771 }
2772
2773 fields = malloc(sizeof(scan_field_t) * argc / 2);
2774
2775 for (i = 0; i < argc / 2; i++)
2776 {
2777 tap = jtag_TapByString( args[i*2] );
2778 if (tap==NULL)
2779 {
2780 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2781 return ERROR_FAIL;
2782 }
2783 int field_size = tap->ir_length;
2784 fields[i].tap = tap;
2785 fields[i].out_value = malloc(CEIL(field_size, 8));
2786 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2787 fields[i].in_value = NULL;
2788 fields[i].in_check_mask = NULL;
2789 fields[i].in_handler = NULL;
2790 fields[i].in_handler_priv = NULL;
2791 }
2792
2793 jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
2794 /* did we have an endstate? */
2795 if (endstate != TAP_INVALID)
2796 jtag_add_end_state(endstate);
2797
2798 jtag_execute_queue();
2799
2800 for (i = 0; i < argc / 2; i++)
2801 free(fields[i].out_value);
2802
2803 free (fields);
2804
2805 return ERROR_OK;
2806 }
2807
2808 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2809 {
2810 int retval;
2811 scan_field_t *fields;
2812 int num_fields;
2813 int field_count = 0;
2814 int i, e;
2815 jtag_tap_t *tap;
2816 tap_state_t endstate;
2817
2818 /* args[1] = device
2819 * args[2] = num_bits
2820 * args[3] = hex string
2821 * ... repeat num bits and hex string ...
2822 *
2823 * .. optionally:
2824 * args[N-2] = "-endstate"
2825 * args[N-1] = statename
2826 */
2827 if ((argc < 4) || ((argc % 2)!=0))
2828 {
2829 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2830 return JIM_ERR;
2831 }
2832
2833 /* assume no endstate */
2834 endstate = TAP_INVALID;
2835 /* validate arguments as numbers */
2836 e = JIM_OK;
2837 for (i = 2; i < argc; i+=2)
2838 {
2839 long bits;
2840 const char *cp;
2841
2842 e = Jim_GetLong(interp, args[i], &bits);
2843 /* If valid - try next arg */
2844 if( e == JIM_OK ){
2845 continue;
2846 }
2847
2848 /* Not valid.. are we at the end? */
2849 if ( ((i+2) != argc) ){
2850 /* nope, then error */
2851 return e;
2852 }
2853
2854 /* it could be: "-endstate FOO" */
2855
2856 /* get arg as a string. */
2857 cp = Jim_GetString( args[i], NULL );
2858 /* is it the magic? */
2859 if( 0 == strcmp( "-endstate", cp ) ){
2860 /* is the statename valid? */
2861 cp = Jim_GetString( args[i+1], NULL );
2862
2863 /* see if it is a valid state name */
2864 endstate = tap_state_by_name(cp);
2865 if( endstate < 0 ){
2866 /* update the error message */
2867 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2868 } else {
2869 /* valid - so clear the error */
2870 e = JIM_OK;
2871 /* and remove the last 2 args */
2872 argc -= 2;
2873 }
2874 }
2875
2876 /* Still an error? */
2877 if( e != JIM_OK ){
2878 return e; /* too bad */
2879 }
2880 } /* validate args */
2881
2882 tap = jtag_TapByJimObj( interp, args[1] );
2883 if( tap == NULL ){
2884 return JIM_ERR;
2885 }
2886
2887 num_fields=(argc-2)/2;
2888 fields = malloc(sizeof(scan_field_t) * num_fields);
2889 for (i = 2; i < argc; i+=2)
2890 {
2891 long bits;
2892 int len;
2893 const char *str;
2894
2895 Jim_GetLong(interp, args[i], &bits);
2896 str = Jim_GetString(args[i+1], &len);
2897
2898 fields[field_count].tap = tap;
2899 fields[field_count].num_bits = bits;
2900 fields[field_count].out_value = malloc(CEIL(bits, 8));
2901 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2902 fields[field_count].in_value = fields[field_count].out_value;
2903 fields[field_count].in_check_mask = NULL;
2904 fields[field_count].in_check_value = NULL;
2905 fields[field_count].in_handler = NULL;
2906 fields[field_count++].in_handler_priv = NULL;
2907 }
2908
2909 jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
2910 /* did we get an end state? */
2911 if (endstate != TAP_INVALID)
2912 jtag_add_end_state(endstate);
2913
2914 retval = jtag_execute_queue();
2915 if (retval != ERROR_OK)
2916 {
2917 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2918 return JIM_ERR;
2919 }
2920
2921 field_count=0;
2922 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2923 for (i = 2; i < argc; i+=2)
2924 {
2925 long bits;
2926 char *str;
2927
2928 Jim_GetLong(interp, args[i], &bits);
2929 str = buf_to_str(fields[field_count].in_value, bits, 16);
2930 free(fields[field_count].out_value);
2931
2932 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2933 free(str);
2934 field_count++;
2935 }
2936
2937 Jim_SetResult(interp, list);
2938
2939 free(fields);
2940
2941 return JIM_OK;
2942 }
2943
2944 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2945 {
2946 if (argc == 1)
2947 {
2948 if (strcmp(args[0], "enable") == 0)
2949 {
2950 jtag_verify_capture_ir = 1;
2951 }
2952 else if (strcmp(args[0], "disable") == 0)
2953 {
2954 jtag_verify_capture_ir = 0;
2955 } else
2956 {
2957 return ERROR_COMMAND_SYNTAX_ERROR;
2958 }
2959 } else if (argc != 0)
2960 {
2961 return ERROR_COMMAND_SYNTAX_ERROR;
2962 }
2963
2964 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2965
2966 return ERROR_OK;
2967 }
2968
2969 int jtag_power_dropout(int *dropout)
2970 {
2971 return jtag->power_dropout(dropout);
2972 }
2973
2974 int jtag_srst_asserted(int *srst_asserted)
2975 {
2976 return jtag->srst_asserted(srst_asserted);
2977 }
2978
2979 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2980 {
2981 jtag_tap_event_action_t * jteap;
2982 int done;
2983
2984 jteap = tap->event_action;
2985
2986 done = 0;
2987 while (jteap) {
2988 if (jteap->event == e) {
2989 done = 1;
2990 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2991 tap->dotted_name,
2992 e,
2993 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2994 Jim_GetString(jteap->body, NULL) );
2995 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
2996 Jim_PrintErrorMessage(interp);
2997 }
2998 }
2999
3000 jteap = jteap->next;
3001 }
3002
3003 if (!done) {
3004 LOG_DEBUG( "event %d %s - no action",
3005 e,
3006 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3007 }
3008 }
3009
3010 /*-----<Cable Helper API>---------------------------------------*/
3011
3012 /* these Cable Helper API functions are all documented in the jtag.h header file,
3013 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3014 is setup to prefer its docs in the header file, no documentation is here, for
3015 if it were, it would have to be doubly maintained.
3016 */
3017
3018 /**
3019 * @see tap_set_state() and tap_get_state() accessors.
3020 * Actual name is not important since accessors hide it.
3021 */
3022 static tap_state_t state_follower = TAP_RESET;
3023
3024 void tap_set_state_impl( tap_state_t new_state )
3025 {
3026 /* this is the state we think the TAPs are in now, was cur_state */
3027 state_follower = new_state;
3028 }
3029
3030 tap_state_t tap_get_state()
3031 {
3032 return state_follower;
3033 }
3034
3035 /**
3036 * @see tap_set_end_state() and tap_get_end_state() accessors.
3037 * Actual name is not important because accessors hide it.
3038 */
3039 static tap_state_t end_state_follower = TAP_RESET;
3040
3041 void tap_set_end_state( tap_state_t new_end_state )
3042 {
3043 /* this is the state we think the TAPs will be in at completion of the
3044 current TAP operation, was end_state
3045 */
3046 end_state_follower = new_end_state;
3047 }
3048
3049 tap_state_t tap_get_end_state()
3050 {
3051 return end_state_follower;
3052 }
3053
3054
3055 int tap_move_ndx( tap_state_t astate )
3056 {
3057 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3058
3059 int ndx;
3060
3061 switch( astate )
3062 {
3063 case TAP_RESET: ndx = 0; break;
3064 case TAP_DRSHIFT: ndx = 2; break;
3065 case TAP_DRPAUSE: ndx = 3; break;
3066 case TAP_IDLE: ndx = 1; break;
3067 case TAP_IRSHIFT: ndx = 4; break;
3068 case TAP_IRPAUSE: ndx = 5; break;
3069 default:
3070 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3071 exit(1);
3072 }
3073
3074 return ndx;
3075 }
3076
3077
3078 /* tap_move[i][j]: tap movement command to go from state i to state j
3079 * 0: Test-Logic-Reset
3080 * 1: Run-Test/Idle
3081 * 2: Shift-DR
3082 * 3: Pause-DR
3083 * 4: Shift-IR
3084 * 5: Pause-IR
3085 *
3086 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3087 */
3088 static struct
3089 {
3090 u8 bits;
3091 u8 bit_count;
3092
3093 } tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */
3094 {
3095 /* value clocked to TMS to move from one of six stable states to another.
3096 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3097 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3098 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3099 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3100 */
3101
3102 /*
3103 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3104 * Read the bits from LSBit first to MSBit last (right-to-left).
3105 */
3106 #define HEX__(n) 0x##n##LU
3107
3108 #define B8__(x) \
3109 (((x) & 0x0000000FLU)?(1<<0):0) \
3110 +(((x) & 0x000000F0LU)?(1<<1):0) \
3111 +(((x) & 0x00000F00LU)?(1<<2):0) \
3112 +(((x) & 0x0000F000LU)?(1<<3):0) \
3113 +(((x) & 0x000F0000LU)?(1<<4):0) \
3114 +(((x) & 0x00F00000LU)?(1<<5):0) \
3115 +(((x) & 0x0F000000LU)?(1<<6):0) \
3116 +(((x) & 0xF0000000LU)?(1<<7):0)
3117
3118 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3119
3120 #if 0 && ((BUILD_FT2232_FTD2XX==1) || (BUILD_FT2232_LIBFTDI==1))
3121 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3122
3123 OK, I added Peter's version of the state table, and it works OK for
3124 me on MC1322x. I've recreated the jlink portion of patch with this
3125 new state table. His changes to my state table are pretty minor in
3126 terms of total transitions, but Peter feels that his version fixes
3127 some long-standing problems.
3128 Jeff
3129
3130 I added the bit count into the table
3131 Dick
3132 */
3133
3134 /* to state: */
3135 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3136 { B8(11111,5), B8(0,1), B8(0010,4), B8(01010,5), B8(00110,5), B8(010110,6) }, /* RESET */
3137 { B8(11111,5), B8(0,1), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3138 { B8(11111,5), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3139 { B8(11111,5), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3140 { B8(11111,5), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3141 { B8(11111,5), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3142
3143 #else /* this is the old table, converted from hex and with the bit_count set to 7 for each combo, like before */
3144
3145 /* to state: */
3146 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3147 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3148 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3149 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3150 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3151 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3152 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0100000,7), B8(0101111,7) }, /* IRPAUSE */
3153
3154 #endif
3155
3156 #if 0 /* keeping old hex stuff for awhile, for reference */
3157 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
3158 { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */
3159 { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */
3160 { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */
3161 { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */
3162 { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */
3163 { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */
3164 #endif
3165 };
3166
3167
3168 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3169 {
3170 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bits;
3171 }
3172
3173
3174 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
3175 {
3176 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
3177 }
3178
3179
3180 bool tap_is_state_stable(tap_state_t astate)
3181 {
3182 bool is_stable;
3183
3184 /* A switch() is used because it is symbol dependent
3185 (not value dependent like an array), and can also check bounds.
3186 */
3187 switch( astate )
3188 {
3189 case TAP_RESET:
3190 case TAP_IDLE:
3191 case TAP_DRSHIFT:
3192 case TAP_DRPAUSE:
3193 case TAP_IRSHIFT:
3194 case TAP_IRPAUSE:
3195 is_stable = true;
3196 break;
3197 default:
3198 is_stable = false;
3199 }
3200
3201 return is_stable;
3202 }
3203
3204 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3205 {
3206 tap_state_t new_state;
3207
3208 /* A switch is used because it is symbol dependent and not value dependent
3209 like an array. Also it can check for out of range conditions.
3210 */
3211
3212 if (tms)
3213 {
3214 switch (cur_state)
3215 {
3216 case TAP_RESET:
3217 new_state = cur_state;
3218 break;
3219 case TAP_IDLE:
3220 case TAP_DRUPDATE:
3221 case TAP_IRUPDATE:
3222 new_state = TAP_DRSELECT;
3223 break;
3224 case TAP_DRSELECT:
3225 new_state = TAP_IRSELECT;
3226 break;
3227 case TAP_DRCAPTURE:
3228 case TAP_DRSHIFT:
3229 new_state = TAP_DREXIT1;
3230 break;
3231 case TAP_DREXIT1:
3232 case TAP_DREXIT2:
3233 new_state = TAP_DRUPDATE;
3234 break;
3235 case TAP_DRPAUSE:
3236 new_state = TAP_DREXIT2;
3237 break;
3238 case TAP_IRSELECT:
3239 new_state = TAP_RESET;
3240 break;
3241 case TAP_IRCAPTURE:
3242 case TAP_IRSHIFT:
3243 new_state = TAP_IREXIT1;
3244 break;
3245 case TAP_IREXIT1:
3246 case TAP_IREXIT2:
3247 new_state = TAP_IRUPDATE;
3248 break;
3249 case TAP_IRPAUSE:
3250 new_state = TAP_IREXIT2;
3251 break;
3252 default:
3253 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3254 exit(1);
3255 break;
3256 }
3257 }
3258 else
3259 {
3260 switch (cur_state)
3261 {
3262 case TAP_RESET:
3263 case TAP_IDLE:
3264 case TAP_DRUPDATE:
3265 case TAP_IRUPDATE:
3266 new_state = TAP_IDLE;
3267 break;
3268 case TAP_DRSELECT:
3269 new_state = TAP_DRCAPTURE;
3270 break;
3271 case TAP_DRCAPTURE:
3272 case TAP_DRSHIFT:
3273 case TAP_DREXIT2:
3274 new_state = TAP_DRSHIFT;
3275 break;
3276 case TAP_DREXIT1:
3277 case TAP_DRPAUSE:
3278 new_state = TAP_DRPAUSE;
3279 break;
3280 case TAP_IRSELECT:
3281 new_state = TAP_IRCAPTURE;
3282 break;
3283 case TAP_IRCAPTURE:
3284 case TAP_IRSHIFT:
3285 case TAP_IREXIT2:
3286 new_state = TAP_IRSHIFT;
3287 break;
3288 case TAP_IREXIT1:
3289 case TAP_IRPAUSE:
3290 new_state = TAP_IRPAUSE;
3291 break;
3292 default:
3293 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3294 exit(1);
3295 break;
3296 }
3297 }
3298
3299 return new_state;
3300 }
3301
3302 const char* tap_state_name(tap_state_t state)
3303 {
3304 const char* ret;
3305
3306 switch( state )
3307 {
3308 case TAP_RESET: ret = "RESET"; break;
3309 case TAP_IDLE: ret = "RUN/IDLE"; break;
3310 case TAP_DRSELECT: ret = "DRSELECT"; break;
3311 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
3312 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
3313 case TAP_DREXIT1: ret = "DREXIT1"; break;
3314 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
3315 case TAP_DREXIT2: ret = "DREXIT2"; break;
3316 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
3317 case TAP_IRSELECT: ret = "IRSELECT"; break;
3318 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3319 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3320 case TAP_IREXIT1: ret = "IREXIT1"; break;
3321 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3322 case TAP_IREXIT2: ret = "IREXIT2"; break;
3323 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3324 default: ret = "???";
3325 }
3326
3327 return ret;
3328 }
3329
3330 static tap_state_t tap_state_by_name( const char *name )
3331 {
3332 tap_state_t x;
3333
3334 for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3335 /* be nice to the human */
3336 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3337 return x;
3338 }
3339 }
3340 /* not found */
3341 return TAP_INVALID;
3342 }
3343
3344 #ifdef _DEBUG_JTAG_IO_
3345
3346 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3347 do { buf[len] = bit ? '1' : '0'; } while(0)
3348 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3349 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3350 tap_state_name(a), tap_state_name(b), astr, bstr)
3351
3352 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3353 unsigned tap_bits, tap_state_t next_state)
3354 {
3355 const u8 *tms_buffer;
3356 const u8 *tdi_buffer;
3357 unsigned tap_bytes;
3358 unsigned cur_byte;
3359 unsigned cur_bit;
3360
3361 unsigned tap_out_bits;
3362 char tms_str[33];
3363 char tdi_str[33];
3364
3365 tap_state_t last_state;
3366
3367 // set startstate (and possibly last, if tap_bits == 0)
3368 last_state = next_state;
3369 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3370
3371 tms_buffer = (const u8 *)tms_buf;
3372 tdi_buffer = (const u8 *)tdi_buf;
3373
3374 tap_bytes = TAP_SCAN_BYTES(tap_bits);
3375 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3376
3377 tap_out_bits = 0;
3378 for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3379 {
3380 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3381 {
3382 // make sure we do not run off the end of the buffers
3383 unsigned tap_bit = cur_byte * 8 + cur_bit;
3384 if (tap_bit == tap_bits)
3385 break;
3386
3387 // check and save TMS bit
3388 tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3389 JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3390
3391 // use TMS bit to find the next TAP state
3392 next_state = tap_state_transition(last_state, tap_bit);
3393
3394 // check and store TDI bit
3395 tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3396 JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3397
3398 // increment TAP bits
3399 tap_out_bits++;
3400
3401 // Only show TDO bits on state transitions, or
3402 // after some number of bits in the same state.
3403 if ((next_state == last_state) && (tap_out_bits < 32))
3404 continue;
3405
3406 // terminate strings and display state transition
3407 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3408 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3409
3410 // reset state
3411 last_state = next_state;
3412 tap_out_bits = 0;
3413 }
3414 }
3415
3416 if (tap_out_bits)
3417 {
3418 // terminate strings and display state transition
3419 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3420 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3421 }
3422
3423 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3424
3425 return next_state;
3426 }
3427 #endif // _DEBUG_JTAG_IO_
3428
3429 /*-----</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)