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