Code Review / openocd.git / blob
? search:


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