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