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