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