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