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