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