Code Review / openocd.git / blob
? search:


5e29082ce93c28fd4f8ae49bcb653566b3d00058
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include "replacements.h"
28
29 #include "jtag.h"
30
31 #include "command.h"
32 #include "log.h"
33
34 #include "stdlib.h"
35 #include "string.h"
36 #include <unistd.h>
37
38 /* note that this is not marked as static as it must be available from outside jtag.c for those
39 that implement the jtag_xxx() minidriver layer
40 */
41 int jtag_error=ERROR_OK;
42
43
44 char* tap_state_strings[16] =
45 {
46 "tlr",
47 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
48 "rti",
49 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
50 };
51
52 typedef struct cmd_queue_page_s
53 {
54 void *address;
55 size_t used;
56 struct cmd_queue_page_s *next;
57 } cmd_queue_page_t;
58
59 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
60 static cmd_queue_page_t *cmd_queue_pages = NULL;
61
62 /* tap_move[i][j]: tap movement command to go from state i to state j
63 * 0: Test-Logic-Reset
64 * 1: Run-Test/Idle
65 * 2: Shift-DR
66 * 3: Pause-DR
67 * 4: Shift-IR
68 * 5: Pause-IR
69 *
70 * SD->SD and SI->SI have to be caught in interface specific code
71 */
72 u8 tap_move[6][6] =
73 {
74 /* TLR RTI SD PD SI PI */
75 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
76 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
77 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
78 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
79 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
80 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
81 };
82
83 int tap_move_map[16] = {
84 0, -1, -1, 2, -1, 3, -1, -1,
85 1, -1, -1, 4, -1, 5, -1, -1
86 };
87
88 tap_transition_t tap_transitions[16] =
89 {
90 {TAP_TLR, TAP_RTI}, /* TLR */
91 {TAP_SIS, TAP_CD}, /* SDS */
92 {TAP_E1D, TAP_SD}, /* CD */
93 {TAP_E1D, TAP_SD}, /* SD */
94 {TAP_UD, TAP_PD}, /* E1D */
95 {TAP_E2D, TAP_PD}, /* PD */
96 {TAP_UD, TAP_SD}, /* E2D */
97 {TAP_SDS, TAP_RTI}, /* UD */
98 {TAP_SDS, TAP_RTI}, /* RTI */
99 {TAP_TLR, TAP_CI}, /* SIS */
100 {TAP_E1I, TAP_SI}, /* CI */
101 {TAP_E1I, TAP_SI}, /* SI */
102 {TAP_UI, TAP_PI}, /* E1I */
103 {TAP_E2I, TAP_PI}, /* PI */
104 {TAP_UI, TAP_SI}, /* E2I */
105 {TAP_SDS, TAP_RTI} /* UI */
106 };
107
108 char* jtag_event_strings[] =
109 {
110 "JTAG controller reset (TLR or TRST)"
111 };
112
113 /* kludge!!!! these are just global variables that the
114 * interface use internally. They really belong
115 * inside the drivers, but we don't want to break
116 * linking the drivers!!!!
117 */
118 enum tap_state end_state = TAP_TLR;
119 enum tap_state cur_state = TAP_TLR;
120 int jtag_trst = 0;
121 int jtag_srst = 0;
122
123 jtag_command_t *jtag_command_queue = NULL;
124 jtag_command_t **last_comand_pointer = &jtag_command_queue;
125 jtag_device_t *jtag_devices = NULL;
126 int jtag_num_devices = 0;
127 int jtag_ir_scan_size = 0;
128 enum reset_types jtag_reset_config = RESET_NONE;
129 enum tap_state cmd_queue_end_state = TAP_TLR;
130 enum tap_state cmd_queue_cur_state = TAP_TLR;
131
132 int jtag_verify_capture_ir = 1;
133
134 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
135 int jtag_nsrst_delay = 0; /* default to no nSRST delay */
136 int jtag_ntrst_delay = 0; /* default to no nTRST delay */
137
138 /* maximum number of JTAG devices expected in the chain
139 */
140 #define JTAG_MAX_CHAIN_SIZE 20
141
142 /* callbacks to inform high-level handlers about JTAG state changes */
143 jtag_event_callback_t *jtag_event_callbacks;
144
145 /* speed in kHz*/
146 static int speed_khz = 0;
147 /* flag if the kHz speed was defined */
148 static int hasKHz = 0;
149
150 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
151 */
152
153 #if BUILD_ECOSBOARD == 1
154 extern jtag_interface_t zy1000_interface;
155 #endif
156
157 #if BUILD_PARPORT == 1
158 extern jtag_interface_t parport_interface;
159 #endif
160
161 #if BUILD_DUMMY == 1
162 extern jtag_interface_t dummy_interface;
163 #endif
164
165 #if BUILD_FT2232_FTD2XX == 1
166 extern jtag_interface_t ft2232_interface;
167 #endif
168
169 #if BUILD_FT2232_LIBFTDI == 1
170 extern jtag_interface_t ft2232_interface;
171 #endif
172
173 #if BUILD_AMTJTAGACCEL == 1
174 extern jtag_interface_t amt_jtagaccel_interface;
175 #endif
176
177 #if BUILD_EP93XX == 1
178 extern jtag_interface_t ep93xx_interface;
179 #endif
180
181 #if BUILD_AT91RM9200 == 1
182 extern jtag_interface_t at91rm9200_interface;
183 #endif
184
185 #if BUILD_GW16012 == 1
186 extern jtag_interface_t gw16012_interface;
187 #endif
188
189 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
190 extern jtag_interface_t presto_interface;
191 #endif
192
193 #if BUILD_USBPROG == 1
194 extern jtag_interface_t usbprog_interface;
195 #endif
196
197 #if BUILD_JLINK == 1
198 extern jtag_interface_t jlink_interface;
199 #endif
200
201 jtag_interface_t *jtag_interfaces[] = {
202 #if BUILD_ECOSBOARD == 1
203 &zy1000_interface,
204 #endif
205 #if BUILD_PARPORT == 1
206 &parport_interface,
207 #endif
208 #if BUILD_DUMMY == 1
209 &dummy_interface,
210 #endif
211 #if BUILD_FT2232_FTD2XX == 1
212 &ft2232_interface,
213 #endif
214 #if BUILD_FT2232_LIBFTDI == 1
215 &ft2232_interface,
216 #endif
217 #if BUILD_AMTJTAGACCEL == 1
218 &amt_jtagaccel_interface,
219 #endif
220 #if BUILD_EP93XX == 1
221 &ep93xx_interface,
222 #endif
223 #if BUILD_AT91RM9200 == 1
224 &at91rm9200_interface,
225 #endif
226 #if BUILD_GW16012 == 1
227 &gw16012_interface,
228 #endif
229 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
230 &presto_interface,
231 #endif
232 #if BUILD_USBPROG == 1
233 &usbprog_interface,
234 #endif
235 #if BUILD_JLINK == 1
236 &jlink_interface,
237 #endif
238 NULL,
239 };
240
241 jtag_interface_t *jtag = NULL;
242
243 /* configuration */
244 jtag_interface_t *jtag_interface = NULL;
245 int jtag_speed = 0;
246
247
248
249 /* forward declarations */
250 void jtag_add_pathmove(int num_states, enum tap_state *path);
251 void jtag_add_runtest(int num_cycles, enum tap_state endstate);
252 void jtag_add_end_state(enum tap_state endstate);
253 void jtag_add_sleep(u32 us);
254 int jtag_execute_queue(void);
255
256
257 /* jtag commands */
258 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
259 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
260 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
261 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
262 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
263 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
264 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
265
266 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
267
268 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
269 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
270 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
271 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
272 int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
273
274 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
275
276 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
277 {
278 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
279
280 if (callback == NULL)
281 {
282 return ERROR_INVALID_ARGUMENTS;
283 }
284
285 if (*callbacks_p)
286 {
287 while ((*callbacks_p)->next)
288 callbacks_p = &((*callbacks_p)->next);
289 callbacks_p = &((*callbacks_p)->next);
290 }
291
292 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
293 (*callbacks_p)->callback = callback;
294 (*callbacks_p)->priv = priv;
295 (*callbacks_p)->next = NULL;
296
297 return ERROR_OK;
298 }
299
300 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
301 {
302 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
303
304 if (callback == NULL)
305 {
306 return ERROR_INVALID_ARGUMENTS;
307 }
308
309 while (*callbacks_p)
310 {
311 jtag_event_callback_t **next = &((*callbacks_p)->next);
312 if ((*callbacks_p)->callback == callback)
313 {
314 free(*callbacks_p);
315 *callbacks_p = *next;
316 }
317 callbacks_p = next;
318 }
319
320 return ERROR_OK;
321 }
322
323 int jtag_call_event_callbacks(enum jtag_event event)
324 {
325 jtag_event_callback_t *callback = jtag_event_callbacks;
326
327 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
328
329 while (callback)
330 {
331 callback->callback(event, callback->priv);
332 callback = callback->next;
333 }
334
335 return ERROR_OK;
336 }
337
338 /* returns a pointer to the pointer of the last command in queue
339 * this may be a pointer to the root pointer (jtag_command_queue)
340 * or to the next member of the last but one command
341 */
342 jtag_command_t** jtag_get_last_command_p(void)
343 {
344 /* jtag_command_t *cmd = jtag_command_queue;
345
346 if (cmd)
347 while (cmd->next)
348 cmd = cmd->next;
349 else
350 return &jtag_command_queue;
351
352 return &cmd->next;*/
353
354 return last_comand_pointer;
355 }
356
357 /* returns a pointer to the n-th device in the scan chain */
358 jtag_device_t* jtag_get_device(int num)
359 {
360 jtag_device_t *device = jtag_devices;
361 int i = 0;
362
363 while (device)
364 {
365 if (num == i)
366 return device;
367 device = device->next;
368 i++;
369 }
370
371 LOG_ERROR("jtag device number %d not defined", num);
372 return NULL;
373 }
374
375 void* cmd_queue_alloc(size_t size)
376 {
377 cmd_queue_page_t **p_page = &cmd_queue_pages;
378 int offset;
379 u8 *t;
380
381 if (*p_page)
382 {
383 while ((*p_page)->next)
384 p_page = &((*p_page)->next);
385 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
386 p_page = &((*p_page)->next);
387 }
388
389 if (!*p_page)
390 {
391 *p_page = malloc(sizeof(cmd_queue_page_t));
392 (*p_page)->used = 0;
393 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
394 (*p_page)->next = NULL;
395 }
396
397 offset = (*p_page)->used;
398 (*p_page)->used += size;
399
400 t=(u8 *)((*p_page)->address);
401 return t + offset;
402 }
403
404 void cmd_queue_free(void)
405 {
406 cmd_queue_page_t *page = cmd_queue_pages;
407
408 while (page)
409 {
410 cmd_queue_page_t *last = page;
411 free(page->address);
412 page = page->next;
413 free(last);
414 }
415
416 cmd_queue_pages = NULL;
417 }
418
419 static void jtag_prelude1(void)
420 {
421 if (jtag_trst == 1)
422 {
423 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
424 jtag_error=ERROR_JTAG_TRST_ASSERTED;
425 return;
426 }
427
428 if (cmd_queue_end_state == TAP_TLR)
429 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
430 }
431
432 static void jtag_prelude(enum tap_state state)
433 {
434 jtag_prelude1();
435
436 if (state != -1)
437 jtag_add_end_state(state);
438
439 cmd_queue_cur_state = cmd_queue_end_state;
440 }
441
442 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
443 {
444 int retval;
445
446 jtag_prelude(state);
447
448 retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
449 if (retval!=ERROR_OK)
450 jtag_error=retval;
451 }
452
453 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
454 {
455 jtag_command_t **last_cmd;
456 jtag_device_t *device;
457 int i, j;
458 int scan_size = 0;
459
460
461 last_cmd = jtag_get_last_command_p();
462
463 /* allocate memory for a new list member */
464 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
465 (*last_cmd)->next = NULL;
466 last_comand_pointer = &((*last_cmd)->next);
467 (*last_cmd)->type = JTAG_SCAN;
468
469 /* allocate memory for ir scan command */
470 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
471 (*last_cmd)->cmd.scan->ir_scan = 1;
472 (*last_cmd)->cmd.scan->num_fields = jtag_num_devices; /* one field per device */
473 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(jtag_num_devices * sizeof(scan_field_t));
474 (*last_cmd)->cmd.scan->end_state = state;
475
476 for (i = 0; i < jtag_num_devices; i++)
477 {
478 int found = 0;
479 device = jtag_get_device(i);
480 if (device == NULL)
481 {
482 exit(-1);
483 }
484 scan_size = device->ir_length;
485 (*last_cmd)->cmd.scan->fields[i].device = i;
486 (*last_cmd)->cmd.scan->fields[i].num_bits = scan_size;
487 (*last_cmd)->cmd.scan->fields[i].in_value = NULL;
488 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; /* disable verification by default */
489
490 /* search the list */
491 for (j = 0; j < num_fields; j++)
492 {
493 if (i == fields[j].device)
494 {
495 found = 1;
496 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
497 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
498
499 if (jtag_verify_capture_ir)
500 {
501 if (fields[j].in_handler==NULL)
502 {
503 jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL);
504 } else
505 {
506 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler;
507 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv;
508 (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected;
509 (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask;
510 }
511 }
512
513 device->bypass = 0;
514 break;
515 }
516 }
517
518 if (!found)
519 {
520 /* if a device isn't listed, set it to BYPASS */
521 (*last_cmd)->cmd.scan->fields[i].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
522 (*last_cmd)->cmd.scan->fields[i].out_mask = NULL;
523 device->bypass = 1;
524
525 }
526
527 /* update device information */
528 buf_cpy((*last_cmd)->cmd.scan->fields[i].out_value, jtag_get_device(i)->cur_instr, scan_size);
529 }
530
531 return ERROR_OK;
532 }
533
534 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
535 {
536 int retval;
537
538 jtag_prelude(state);
539
540 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
541 if (retval!=ERROR_OK)
542 jtag_error=retval;
543 }
544
545 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
546 {
547 int i;
548 jtag_command_t **last_cmd;
549
550 last_cmd = jtag_get_last_command_p();
551
552 /* allocate memory for a new list member */
553 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
554 (*last_cmd)->next = NULL;
555 last_comand_pointer = &((*last_cmd)->next);
556 (*last_cmd)->type = JTAG_SCAN;
557
558 /* allocate memory for ir scan command */
559 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
560 (*last_cmd)->cmd.scan->ir_scan = 1;
561 (*last_cmd)->cmd.scan->num_fields = num_fields;
562 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
563 (*last_cmd)->cmd.scan->end_state = state;
564
565 for (i = 0; i < num_fields; i++)
566 {
567 int num_bits = fields[i].num_bits;
568 int num_bytes = CEIL(fields[i].num_bits, 8);
569 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
570 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
571 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
572 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
573 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
574 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
575 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
576 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
577 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
578 }
579 return ERROR_OK;
580 }
581
582 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
583 {
584 int retval;
585
586 jtag_prelude(state);
587
588 retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
589 if (retval!=ERROR_OK)
590 jtag_error=retval;
591 }
592
593 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
594 {
595 int i, j;
596 int bypass_devices = 0;
597 int field_count = 0;
598 int scan_size;
599
600 jtag_command_t **last_cmd = jtag_get_last_command_p();
601 jtag_device_t *device = jtag_devices;
602
603 /* count devices in bypass */
604 while (device)
605 {
606 if (device->bypass)
607 bypass_devices++;
608 device = device->next;
609 }
610 if (bypass_devices >= jtag_num_devices)
611 {
612 LOG_ERROR("all devices in bypass");
613 return ERROR_JTAG_DEVICE_ERROR;
614 }
615
616 /* allocate memory for a new list member */
617 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
618 last_comand_pointer = &((*last_cmd)->next);
619 (*last_cmd)->next = NULL;
620 (*last_cmd)->type = JTAG_SCAN;
621
622 /* allocate memory for dr scan command */
623 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
624 (*last_cmd)->cmd.scan->ir_scan = 0;
625 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
626 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
627 (*last_cmd)->cmd.scan->end_state = state;
628
629 for (i = 0; i < jtag_num_devices; i++)
630 {
631 int found = 0;
632 (*last_cmd)->cmd.scan->fields[field_count].device = i;
633
634 for (j = 0; j < num_fields; j++)
635 {
636 if (i == fields[j].device)
637 {
638 found = 1;
639 scan_size = fields[j].num_bits;
640 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
641 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
642 (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
643 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
644 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
645 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
646 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
647 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
648 }
649 }
650 if (!found)
651 {
652 #ifdef _DEBUG_JTAG_IO_
653 /* if a device isn't listed, the BYPASS register should be selected */
654 if (!jtag_get_device(i)->bypass)
655 {
656 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
657 exit(-1);
658 }
659 #endif
660 /* program the scan field to 1 bit length, and ignore it's value */
661 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
662 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
663 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
664 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
665 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
666 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
667 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
668 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
669 }
670 else
671 {
672 #ifdef _DEBUG_JTAG_IO_
673 /* if a device is listed, the BYPASS register must not be selected */
674 if (jtag_get_device(i)->bypass)
675 {
676 LOG_ERROR("BUG: scan data for a device in BYPASS");
677 exit(-1);
678 }
679 #endif
680 }
681 }
682 return ERROR_OK;
683 }
684
685 void MINIDRIVER(interface_jtag_add_dr_out)(int device_num,
686 int num_fields,
687 const int *num_bits,
688 const u32 *value,
689 enum tap_state end_state)
690 {
691 int i;
692 int field_count = 0;
693 int scan_size;
694 int bypass_devices = 0;
695
696 jtag_command_t **last_cmd = jtag_get_last_command_p();
697 jtag_device_t *device = jtag_devices;
698 /* count devices in bypass */
699 while (device)
700 {
701 if (device->bypass)
702 bypass_devices++;
703 device = device->next;
704 }
705
706 /* allocate memory for a new list member */
707 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
708 last_comand_pointer = &((*last_cmd)->next);
709 (*last_cmd)->next = NULL;
710 (*last_cmd)->type = JTAG_SCAN;
711
712 /* allocate memory for dr scan command */
713 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
714 (*last_cmd)->cmd.scan->ir_scan = 0;
715 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
716 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
717 (*last_cmd)->cmd.scan->end_state = end_state;
718
719 for (i = 0; i < jtag_num_devices; i++)
720 {
721 (*last_cmd)->cmd.scan->fields[field_count].device = i;
722
723 if (i == device_num)
724 {
725 int j;
726 #ifdef _DEBUG_JTAG_IO_
727 /* if a device is listed, the BYPASS register must not be selected */
728 if (jtag_get_device(i)->bypass)
729 {
730 LOG_ERROR("BUG: scan data for a device in BYPASS");
731 exit(-1);
732 }
733 #endif
734 for (j = 0; j < num_fields; j++)
735 {
736 u8 out_value[4];
737 scan_size = num_bits[j];
738 buf_set_u32(out_value, 0, scan_size, value[j]);
739 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
740 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
741 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
742 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
743 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
744 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
745 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
746 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
747 }
748 } else
749 {
750 #ifdef _DEBUG_JTAG_IO_
751 /* if a device isn't listed, the BYPASS register should be selected */
752 if (!jtag_get_device(i)->bypass)
753 {
754 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
755 exit(-1);
756 }
757 #endif
758 /* program the scan field to 1 bit length, and ignore it's value */
759 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
760 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
761 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
762 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
763 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
764 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
765 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
766 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
767 }
768 }
769 }
770
771 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
772 {
773 int retval;
774
775 jtag_prelude(state);
776
777 retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
778 if (retval!=ERROR_OK)
779 jtag_error=retval;
780 }
781
782 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
783 {
784 int i;
785 jtag_command_t **last_cmd = jtag_get_last_command_p();
786
787 /* allocate memory for a new list member */
788 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
789 last_comand_pointer = &((*last_cmd)->next);
790 (*last_cmd)->next = NULL;
791 (*last_cmd)->type = JTAG_SCAN;
792
793 /* allocate memory for scan command */
794 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
795 (*last_cmd)->cmd.scan->ir_scan = 0;
796 (*last_cmd)->cmd.scan->num_fields = num_fields;
797 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
798 (*last_cmd)->cmd.scan->end_state = state;
799
800 for (i = 0; i < num_fields; i++)
801 {
802 int num_bits = fields[i].num_bits;
803 int num_bytes = CEIL(fields[i].num_bits, 8);
804 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
805 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
806 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
807 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
808 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
809 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
810 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
811 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
812 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
813 }
814
815 return ERROR_OK;
816 }
817
818 void jtag_add_tlr(void)
819 {
820 jtag_prelude(TAP_TLR);
821
822 int retval;
823 retval=interface_jtag_add_tlr();
824 if (retval!=ERROR_OK)
825 jtag_error=retval;
826 }
827
828 int MINIDRIVER(interface_jtag_add_tlr)()
829 {
830 enum tap_state state = TAP_TLR;
831 jtag_command_t **last_cmd = jtag_get_last_command_p();
832
833 /* allocate memory for a new list member */
834 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
835 last_comand_pointer = &((*last_cmd)->next);
836 (*last_cmd)->next = NULL;
837 (*last_cmd)->type = JTAG_STATEMOVE;
838
839 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
840 (*last_cmd)->cmd.statemove->end_state = state;
841
842
843 return ERROR_OK;
844 }
845
846 void jtag_add_pathmove(int num_states, enum tap_state *path)
847 {
848 enum tap_state cur_state=cmd_queue_cur_state;
849 int i;
850 int retval;
851
852 /* the last state has to be a stable state */
853 if (tap_move_map[path[num_states - 1]] == -1)
854 {
855 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
856 exit(-1);
857 }
858
859 for (i=0; i<num_states; i++)
860 {
861 if (path[i] == TAP_TLR)
862 {
863 LOG_ERROR("BUG: TAP_TLR is not a valid state for pathmove sequences");
864 exit(-1);
865 }
866 if ((tap_transitions[cur_state].low != path[i])&&
867 (tap_transitions[cur_state].high != path[i]))
868 {
869 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[path[i]]);
870 exit(-1);
871 }
872 cur_state = path[i];
873 }
874
875 jtag_prelude1();
876
877
878 retval=interface_jtag_add_pathmove(num_states, path);
879 cmd_queue_cur_state = path[num_states - 1];
880 if (retval!=ERROR_OK)
881 jtag_error=retval;
882 }
883
884 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path)
885 {
886 jtag_command_t **last_cmd = jtag_get_last_command_p();
887 int i;
888
889 /* allocate memory for a new list member */
890 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
891 last_comand_pointer = &((*last_cmd)->next);
892 (*last_cmd)->next = NULL;
893 (*last_cmd)->type = JTAG_PATHMOVE;
894
895 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
896 (*last_cmd)->cmd.pathmove->num_states = num_states;
897 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states);
898
899 for (i = 0; i < num_states; i++)
900 (*last_cmd)->cmd.pathmove->path[i] = path[i];
901
902 return ERROR_OK;
903 }
904
905 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state)
906 {
907 jtag_command_t **last_cmd = jtag_get_last_command_p();
908
909 /* allocate memory for a new list member */
910 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
911 (*last_cmd)->next = NULL;
912 last_comand_pointer = &((*last_cmd)->next);
913 (*last_cmd)->type = JTAG_RUNTEST;
914
915 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
916 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
917 (*last_cmd)->cmd.runtest->end_state = state;
918
919 return ERROR_OK;
920 }
921
922 void jtag_add_runtest(int num_cycles, enum tap_state state)
923 {
924 int retval;
925
926 jtag_prelude(state);
927
928 /* executed by sw or hw fifo */
929 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
930 if (retval!=ERROR_OK)
931 jtag_error=retval;
932 }
933
934 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
935 {
936 int trst_with_tlr = 0;
937 int retval;
938
939 /* FIX!!! there are *many* different cases here. A better
940 * approach is needed for legal combinations of transitions...
941 */
942 if ((jtag_reset_config & RESET_HAS_SRST)&&
943 (jtag_reset_config & RESET_HAS_TRST)&&
944 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
945 {
946 if (((req_tlr_or_trst&&!jtag_trst)||
947 (!req_tlr_or_trst&&jtag_trst))&&
948 ((req_srst&&!jtag_srst)||
949 (!req_srst&&jtag_srst)))
950 {
951 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
952 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
953 }
954 }
955
956 /* Make sure that jtag_reset_config allows the requested reset */
957 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
958 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
959 {
960 LOG_ERROR("BUG: requested reset would assert trst");
961 jtag_error=ERROR_FAIL;
962 return;
963 }
964
965 /* if TRST pulls SRST, we reset with TAP T-L-R */
966 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
967 {
968 trst_with_tlr = 1;
969 }
970
971 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
972 {
973 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
974 jtag_error=ERROR_FAIL;
975 return;
976 }
977
978 if (req_tlr_or_trst)
979 {
980 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
981 {
982 jtag_trst = 1;
983 } else
984 {
985 trst_with_tlr = 1;
986 }
987 } else
988 {
989 jtag_trst = 0;
990 }
991
992 jtag_srst = req_srst;
993
994 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
995 if (retval!=ERROR_OK)
996 {
997 jtag_error=retval;
998 return;
999 }
1000
1001 if (jtag_srst)
1002 {
1003 LOG_DEBUG("SRST line asserted");
1004 }
1005 else
1006 {
1007 LOG_DEBUG("SRST line released");
1008 if (jtag_nsrst_delay)
1009 jtag_add_sleep(jtag_nsrst_delay * 1000);
1010 }
1011
1012 if (trst_with_tlr)
1013 {
1014 LOG_DEBUG("JTAG reset with TLR instead of TRST");
1015 jtag_add_end_state(TAP_TLR);
1016 jtag_add_tlr();
1017 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1018 return;
1019 }
1020
1021 if (jtag_trst)
1022 {
1023 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1024 * and inform possible listeners about this
1025 */
1026 LOG_DEBUG("TRST line asserted");
1027 cmd_queue_cur_state = TAP_TLR;
1028 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1029 }
1030 else
1031 {
1032 if (jtag_ntrst_delay)
1033 jtag_add_sleep(jtag_ntrst_delay * 1000);
1034 }
1035 }
1036
1037 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1038 {
1039 jtag_command_t **last_cmd = jtag_get_last_command_p();
1040
1041 /* allocate memory for a new list member */
1042 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1043 (*last_cmd)->next = NULL;
1044 last_comand_pointer = &((*last_cmd)->next);
1045 (*last_cmd)->type = JTAG_RESET;
1046
1047 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1048 (*last_cmd)->cmd.reset->trst = req_trst;
1049 (*last_cmd)->cmd.reset->srst = req_srst;
1050
1051 return ERROR_OK;
1052 }
1053
1054 void jtag_add_end_state(enum tap_state state)
1055 {
1056 cmd_queue_end_state = state;
1057 if ((cmd_queue_end_state == TAP_SD)||(cmd_queue_end_state == TAP_SI))
1058 {
1059 LOG_ERROR("BUG: TAP_SD/SI can't be end state. Calling code should use a larger scan field");
1060 }
1061 }
1062
1063 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1064 {
1065 jtag_command_t **last_cmd = jtag_get_last_command_p();
1066
1067 /* allocate memory for a new list member */
1068 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1069 (*last_cmd)->next = NULL;
1070 last_comand_pointer = &((*last_cmd)->next);
1071 (*last_cmd)->type = JTAG_SLEEP;
1072
1073 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1074 (*last_cmd)->cmd.sleep->us = us;
1075
1076 return ERROR_OK;
1077 }
1078
1079 void jtag_add_sleep(u32 us)
1080 {
1081 keep_alive(); /* we might be running on a very slow JTAG clk */
1082 int retval=interface_jtag_add_sleep(us);
1083 if (retval!=ERROR_OK)
1084 jtag_error=retval;
1085 return;
1086 }
1087
1088 int jtag_scan_size(scan_command_t *cmd)
1089 {
1090 int bit_count = 0;
1091 int i;
1092
1093 /* count bits in scan command */
1094 for (i = 0; i < cmd->num_fields; i++)
1095 {
1096 bit_count += cmd->fields[i].num_bits;
1097 }
1098
1099 return bit_count;
1100 }
1101
1102 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1103 {
1104 int bit_count = 0;
1105 int i;
1106
1107 bit_count = jtag_scan_size(cmd);
1108 *buffer = malloc(CEIL(bit_count, 8));
1109
1110 bit_count = 0;
1111
1112 for (i = 0; i < cmd->num_fields; i++)
1113 {
1114 if (cmd->fields[i].out_value)
1115 {
1116 #ifdef _DEBUG_JTAG_IO_
1117 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16);
1118 #endif
1119 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1120 #ifdef _DEBUG_JTAG_IO_
1121 LOG_DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
1122 free(char_buf);
1123 #endif
1124 }
1125
1126 bit_count += cmd->fields[i].num_bits;
1127 }
1128
1129 return bit_count;
1130 }
1131
1132 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1133 {
1134 int i;
1135 int bit_count = 0;
1136 int retval;
1137
1138 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1139 retval = ERROR_OK;
1140
1141 for (i = 0; i < cmd->num_fields; i++)
1142 {
1143 /* if neither in_value nor in_handler
1144 * are specified we don't have to examine this field
1145 */
1146 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1147 {
1148 int num_bits = cmd->fields[i].num_bits;
1149 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1150
1151 #ifdef _DEBUG_JTAG_IO_
1152 char *char_buf;
1153
1154 char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1155 LOG_DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
1156 free(char_buf);
1157 #endif
1158
1159 if (cmd->fields[i].in_value)
1160 {
1161 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1162
1163 if (cmd->fields[i].in_handler)
1164 {
1165 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1166 {
1167 LOG_WARNING("in_handler reported a failed check");
1168 retval = ERROR_JTAG_QUEUE_FAILED;
1169 }
1170 }
1171 }
1172
1173 /* no in_value specified, but a handler takes care of the scanned data */
1174 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1175 {
1176 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1177 {
1178 /* We're going to call the error:handler later, but if the in_handler
1179 * reported an error we report this failure upstream
1180 */
1181 LOG_WARNING("in_handler reported a failed check");
1182 retval = ERROR_JTAG_QUEUE_FAILED;
1183 }
1184 }
1185
1186 free(captured);
1187 }
1188 bit_count += cmd->fields[i].num_bits;
1189 }
1190
1191 return retval;
1192 }
1193
1194 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1195 {
1196 int retval = ERROR_OK;
1197 int num_bits = field->num_bits;
1198
1199 int compare_failed = 0;
1200
1201 if (field->in_check_mask)
1202 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1203 else
1204 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1205
1206 if (compare_failed)
1207 {
1208 /* An error handler could have caught the failing check
1209 * only report a problem when there wasn't a handler, or if the handler
1210 * acknowledged the error
1211 */
1212 if (compare_failed)
1213 {
1214 char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1215 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16);
1216
1217 if (field->in_check_mask)
1218 {
1219 char *in_check_mask_char;
1220 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16);
1221 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char);
1222 free(in_check_mask_char);
1223 }
1224 else
1225 {
1226 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);
1227 }
1228
1229 free(captured_char);
1230 free(in_check_value_char);
1231
1232 retval = ERROR_JTAG_QUEUE_FAILED;
1233 }
1234
1235 }
1236 return retval;
1237 }
1238
1239 /*
1240 set up checking of this field using the in_handler. The values passed in must be valid until
1241 after jtag_execute() has completed.
1242 */
1243 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1244 {
1245 if (value)
1246 field->in_handler = jtag_check_value;
1247 else
1248 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1249 field->in_handler_priv = NULL;
1250 field->in_check_value = value;
1251 field->in_check_mask = mask;
1252 }
1253
1254 enum scan_type jtag_scan_type(scan_command_t *cmd)
1255 {
1256 int i;
1257 int type = 0;
1258
1259 for (i = 0; i < cmd->num_fields; i++)
1260 {
1261 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1262 type |= SCAN_IN;
1263 if (cmd->fields[i].out_value)
1264 type |= SCAN_OUT;
1265 }
1266
1267 return type;
1268 }
1269
1270 int MINIDRIVER(interface_jtag_execute_queue)(void)
1271 {
1272 int retval;
1273
1274 if (jtag==NULL)
1275 {
1276 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1277 return ERROR_FAIL;
1278 }
1279
1280 retval = jtag->execute_queue();
1281
1282 cmd_queue_free();
1283
1284 jtag_command_queue = NULL;
1285 last_comand_pointer = &jtag_command_queue;
1286
1287 return retval;
1288 }
1289
1290 int jtag_execute_queue(void)
1291 {
1292 int retval=interface_jtag_execute_queue();
1293 if (retval==ERROR_OK)
1294 {
1295 retval=jtag_error;
1296 }
1297 jtag_error=ERROR_OK;
1298 return retval;
1299 }
1300
1301 int jtag_reset_callback(enum jtag_event event, void *priv)
1302 {
1303 jtag_device_t *device = priv;
1304
1305 LOG_DEBUG("-");
1306
1307 if (event == JTAG_TRST_ASSERTED)
1308 {
1309 buf_set_ones(device->cur_instr, device->ir_length);
1310 device->bypass = 1;
1311 }
1312
1313 return ERROR_OK;
1314 }
1315
1316 void jtag_sleep(u32 us)
1317 {
1318 alive_sleep(us/1000);
1319 }
1320
1321 /* Try to examine chain layout according to IEEE 1149.1 §12
1322 */
1323 int jtag_examine_chain(void)
1324 {
1325 jtag_device_t *device = jtag_devices;
1326 scan_field_t field;
1327 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1328 int i;
1329 int bit_count;
1330 int device_count = 0;
1331 u8 zero_check = 0x0;
1332 u8 one_check = 0xff;
1333
1334 field.device = 0;
1335 field.num_bits = sizeof(idcode_buffer) * 8;
1336 field.out_value = idcode_buffer;
1337 field.out_mask = NULL;
1338 field.in_value = idcode_buffer;
1339 field.in_check_value = NULL;
1340 field.in_check_mask = NULL;
1341 field.in_handler = NULL;
1342 field.in_handler_priv = NULL;
1343
1344 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1345 {
1346 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1347 }
1348
1349 jtag_add_plain_dr_scan(1, &field, TAP_TLR);
1350 jtag_execute_queue();
1351
1352 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1353 {
1354 zero_check |= idcode_buffer[i];
1355 one_check &= idcode_buffer[i];
1356 }
1357
1358 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1359 if ((zero_check == 0x00) || (one_check == 0xff))
1360 {
1361 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1362 return ERROR_JTAG_INIT_FAILED;
1363 }
1364
1365 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1366 {
1367 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1368 if ((idcode & 1) == 0)
1369 {
1370 /* LSB must not be 0, this indicates a device in bypass */
1371 LOG_WARNING("Device does not have IDCODE");
1372 idcode=0;
1373
1374 bit_count += 1;
1375 }
1376 else
1377 {
1378 u32 manufacturer;
1379 u32 part;
1380 u32 version;
1381
1382 if (idcode == 0x000000FF)
1383 {
1384 int unexpected=0;
1385 /* End of chain (invalid manufacturer ID)
1386 *
1387 * The JTAG examine is the very first thing that happens
1388 *
1389 * A single JTAG device requires only 64 bits to be read back correctly.
1390 *
1391 * The code below adds a check that the rest of the data scanned (640 bits)
1392 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1393 *
1394 * earlier and gives more helpful/explicit error messages.
1395 */
1396 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1397 {
1398 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1399 if (unexpected||(idcode != 0x000000FF))
1400 {
1401 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1402 unexpected = 1;
1403 }
1404 }
1405
1406 break;
1407 }
1408
1409 manufacturer = (idcode & 0xffe) >> 1;
1410 part = (idcode & 0xffff000) >> 12;
1411 version = (idcode & 0xf0000000) >> 28;
1412
1413 LOG_INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1414 idcode, manufacturer, part, version);
1415
1416 bit_count += 32;
1417 }
1418 if (device)
1419 {
1420 device->idcode = idcode;
1421 device = device->next;
1422 }
1423 device_count++;
1424 }
1425
1426 /* see if number of discovered devices matches configuration */
1427 if (device_count != jtag_num_devices)
1428 {
1429 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1430 device_count, jtag_num_devices);
1431 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1432 return ERROR_JTAG_INIT_FAILED;
1433 }
1434
1435 return ERROR_OK;
1436 }
1437
1438 int jtag_validate_chain(void)
1439 {
1440 jtag_device_t *device = jtag_devices;
1441 int total_ir_length = 0;
1442 u8 *ir_test = NULL;
1443 scan_field_t field;
1444 int chain_pos = 0;
1445
1446 while (device)
1447 {
1448 total_ir_length += device->ir_length;
1449 device = device->next;
1450 }
1451
1452 total_ir_length += 2;
1453 ir_test = malloc(CEIL(total_ir_length, 8));
1454 buf_set_ones(ir_test, total_ir_length);
1455
1456 field.device = 0;
1457 field.num_bits = total_ir_length;
1458 field.out_value = ir_test;
1459 field.out_mask = NULL;
1460 field.in_value = ir_test;
1461 field.in_check_value = NULL;
1462 field.in_check_mask = NULL;
1463 field.in_handler = NULL;
1464 field.in_handler_priv = NULL;
1465
1466 jtag_add_plain_ir_scan(1, &field, TAP_TLR);
1467 jtag_execute_queue();
1468
1469 device = jtag_devices;
1470 while (device)
1471 {
1472 if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
1473 {
1474 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1475 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1476 free(cbuf);
1477 free(ir_test);
1478 return ERROR_JTAG_INIT_FAILED;
1479 }
1480 chain_pos += device->ir_length;
1481 device = device->next;
1482 }
1483
1484 if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
1485 {
1486 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1487 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1488 free(cbuf);
1489 free(ir_test);
1490 return ERROR_JTAG_INIT_FAILED;
1491 }
1492
1493 free(ir_test);
1494
1495 return ERROR_OK;
1496 }
1497
1498
1499 static int
1500 jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
1501 {
1502 Jim_GetOptInfo goi;
1503 int e;
1504 Jim_Nvp *n;
1505 struct command_context_s *context;
1506
1507 enum {
1508 JTAG_CMD_INTERFACE,
1509 JTAG_CMD_INIT_RESET,
1510 };
1511
1512 const Jim_Nvp jtag_cmds[] = {
1513 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
1514 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
1515
1516 { .name = NULL, .value = -1 },
1517 };
1518
1519 context = Jim_GetAssocData(interp, "context");
1520 // go past the command
1521 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
1522
1523 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
1524 if( e != JIM_OK ){
1525 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
1526 return e;
1527 }
1528 Jim_SetEmptyResult( goi.interp );
1529 switch( n->value ){
1530 case JTAG_CMD_INTERFACE:
1531 // return the name of the interface
1532 // TCL code might need to know the exact type...
1533 // FUTURE: we allow this as a means to "set" the interface.
1534 if( goi.argc != 0 ){
1535 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1536 return JIM_ERR;
1537 }
1538 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
1539 return JIM_OK;
1540 case JTAG_CMD_INIT_RESET:
1541 if( goi.argc != 0 ){
1542 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1543 return JIM_ERR;
1544 }
1545 e = jtag_init_reset(context);
1546 if( e != ERROR_OK ){
1547 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
1548 return JIM_ERR;
1549 }
1550 return JIM_OK;
1551 }
1552
1553
1554 return JIM_ERR;
1555 }
1556
1557 int jtag_register_commands(struct command_context_s *cmd_ctx)
1558 {
1559 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
1560
1561 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1562 COMMAND_CONFIG, "try to configure interface");
1563 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1564 COMMAND_ANY, "set jtag speed (if supported)");
1565 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1566 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
1567 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1568 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1569 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1570 COMMAND_CONFIG, NULL);
1571 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1572 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1573 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1574 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1575
1576 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1577 COMMAND_EXEC, "print current scan chain configuration");
1578
1579 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1580 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1581 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1582 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1583 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1584 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1585 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1586 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1587 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1588
1589 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1590 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1591 return ERROR_OK;
1592 }
1593
1594 int jtag_interface_init(struct command_context_s *cmd_ctx)
1595 {
1596 if (jtag)
1597 return ERROR_OK;
1598
1599 if (!jtag_interface)
1600 {
1601 /* nothing was previously specified by "interface" command */
1602 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1603 return ERROR_JTAG_INVALID_INTERFACE;
1604 }
1605 if(hasKHz)
1606 {
1607 jtag_interface->khz(speed_khz, &jtag_speed);
1608 hasKHz = 0;
1609 }
1610
1611 if (jtag_interface->init() != ERROR_OK)
1612 return ERROR_JTAG_INIT_FAILED;
1613
1614
1615
1616 jtag = jtag_interface;
1617 return ERROR_OK;
1618 }
1619
1620 static int jtag_init_inner(struct command_context_s *cmd_ctx)
1621 {
1622 jtag_device_t *device;
1623 int retval;
1624
1625 LOG_DEBUG("Init JTAG chain");
1626
1627 device = jtag_devices;
1628 jtag_ir_scan_size = 0;
1629 jtag_num_devices = 0;
1630 while (device != NULL)
1631 {
1632 jtag_ir_scan_size += device->ir_length;
1633 jtag_num_devices++;
1634 device = device->next;
1635 }
1636
1637 jtag_add_tlr();
1638 if ((retval=jtag_execute_queue())!=ERROR_OK)
1639 return retval;
1640
1641 /* examine chain first, as this could discover the real chain layout */
1642 if (jtag_examine_chain() != ERROR_OK)
1643 {
1644 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1645 }
1646
1647 if (jtag_validate_chain() != ERROR_OK)
1648 {
1649 LOG_ERROR("Could not validate JTAG chain, continuing anyway...");
1650 }
1651
1652 return ERROR_OK;
1653 }
1654
1655 int jtag_init_reset(struct command_context_s *cmd_ctx)
1656 {
1657 int retval;
1658
1659 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1660 return retval;
1661
1662 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / TLR");
1663
1664 /* Reset can happen after a power cycle.
1665 *
1666 * Ideally we would only assert TRST or run TLR before the target reset.
1667 *
1668 * However w/srst_pulls_trst, trst is asserted together with the target
1669 * reset whether we want it or not.
1670 *
1671 * NB! Some targets have JTAG circuitry disabled until a
1672 * trst & srst has been asserted.
1673 *
1674 * NB! here we assume nsrst/ntrst delay are sufficient!
1675 *
1676 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1677 *
1678 */
1679 jtag_add_reset(1, 0); /* TLR or TRST */
1680 if (jtag_reset_config & RESET_HAS_SRST)
1681 {
1682 jtag_add_reset(1, 1);
1683 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
1684 jtag_add_reset(0, 1);
1685 }
1686 jtag_add_reset(0, 0);
1687 if ((retval = jtag_execute_queue()) != ERROR_OK)
1688 return retval;
1689
1690 /* Check that we can communication on the JTAG chain + eventually we want to
1691 * be able to perform enumeration only after OpenOCD has started
1692 * telnet and GDB server
1693 *
1694 * That would allow users to more easily perform any magic they need to before
1695 * reset happens.
1696 */
1697 return jtag_init_inner(cmd_ctx);
1698 }
1699
1700 int jtag_init(struct command_context_s *cmd_ctx)
1701 {
1702 int retval;
1703 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1704 return retval;
1705 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
1706 {
1707 return ERROR_OK;
1708 }
1709 return jtag_init_reset(cmd_ctx);
1710 }
1711
1712 static int default_khz(int khz, int *jtag_speed)
1713 {
1714 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1715 return ERROR_FAIL;
1716 }
1717
1718 static int default_speed_div(int speed, int *khz)
1719 {
1720 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1721 return ERROR_FAIL;
1722 }
1723
1724 static int default_power_dropout(int *dropout)
1725 {
1726 *dropout=0; /* by default we can't detect power dropout */
1727 return ERROR_OK;
1728 }
1729
1730 static int default_srst_asserted(int *srst_asserted)
1731 {
1732 *srst_asserted=0; /* by default we can't detect srst asserted */
1733 return ERROR_OK;
1734 }
1735
1736 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1737 {
1738 int i;
1739 int retval;
1740
1741 /* check whether the interface is already configured */
1742 if (jtag_interface)
1743 {
1744 LOG_WARNING("Interface already configured, ignoring");
1745 return ERROR_OK;
1746 }
1747
1748 /* interface name is a mandatory argument */
1749 if (argc < 1 || args[0][0] == '\0')
1750 {
1751 return ERROR_COMMAND_SYNTAX_ERROR;
1752 }
1753
1754 for (i=0; jtag_interfaces[i]; i++)
1755 {
1756 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1757 {
1758 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
1759 {
1760 return retval;
1761 }
1762
1763 jtag_interface = jtag_interfaces[i];
1764
1765 if (jtag_interface->khz == NULL)
1766 {
1767 jtag_interface->khz = default_khz;
1768 }
1769 if (jtag_interface->speed_div == NULL)
1770 {
1771 jtag_interface->speed_div = default_speed_div;
1772 }
1773 if (jtag_interface->power_dropout == NULL)
1774 {
1775 jtag_interface->power_dropout = default_power_dropout;
1776 }
1777 if (jtag_interface->srst_asserted == NULL)
1778 {
1779 jtag_interface->srst_asserted = default_srst_asserted;
1780 }
1781
1782 return ERROR_OK;
1783 }
1784 }
1785
1786 /* no valid interface was found (i.e. the configuration option,
1787 * didn't match one of the compiled-in interfaces
1788 */
1789 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
1790 LOG_ERROR("compiled-in jtag interfaces:");
1791 for (i = 0; jtag_interfaces[i]; i++)
1792 {
1793 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
1794 }
1795
1796 return ERROR_JTAG_INVALID_INTERFACE;
1797 }
1798
1799 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1800 {
1801 jtag_device_t **last_device_p = &jtag_devices;
1802
1803 if (*last_device_p)
1804 {
1805 while ((*last_device_p)->next)
1806 last_device_p = &((*last_device_p)->next);
1807 last_device_p = &((*last_device_p)->next);
1808 }
1809
1810 if (argc < 3)
1811 return ERROR_OK;
1812
1813 *last_device_p = malloc(sizeof(jtag_device_t));
1814 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1815
1816 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1817 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1818 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1819 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1820
1821 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1822 (*last_device_p)->bypass = 1;
1823 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1824
1825 (*last_device_p)->next = NULL;
1826
1827 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1828
1829 jtag_num_devices++;
1830
1831 return ERROR_OK;
1832 }
1833
1834 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1835 {
1836 jtag_device_t *device = jtag_devices;
1837 int device_count = 0;
1838
1839 while (device)
1840 {
1841 u32 expected, expected_mask, cur_instr;
1842 expected = buf_get_u32(device->expected, 0, device->ir_length);
1843 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1844 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1845 command_print(cmd_ctx, "%i: idcode: 0x%8.8x ir length %i, ir capture 0x%x, ir mask 0x%x, current instruction 0x%x", device_count, device->idcode, device->ir_length, expected, expected_mask, cur_instr);
1846 device = device->next;
1847 device_count++;
1848 }
1849
1850 return ERROR_OK;
1851 }
1852
1853 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1854 {
1855 if (argc < 1)
1856 return ERROR_COMMAND_SYNTAX_ERROR;
1857
1858 if (argc >= 1)
1859 {
1860 if (strcmp(args[0], "none") == 0)
1861 jtag_reset_config = RESET_NONE;
1862 else if (strcmp(args[0], "trst_only") == 0)
1863 jtag_reset_config = RESET_HAS_TRST;
1864 else if (strcmp(args[0], "srst_only") == 0)
1865 jtag_reset_config = RESET_HAS_SRST;
1866 else if (strcmp(args[0], "trst_and_srst") == 0)
1867 jtag_reset_config = RESET_TRST_AND_SRST;
1868 else
1869 {
1870 LOG_ERROR("invalid reset_config argument, defaulting to none");
1871 jtag_reset_config = RESET_NONE;
1872 return ERROR_INVALID_ARGUMENTS;
1873 }
1874 }
1875
1876 if (argc >= 2)
1877 {
1878 if (strcmp(args[1], "separate") == 0)
1879 {
1880 /* seperate reset lines - default */
1881 } else
1882 {
1883 if (strcmp(args[1], "srst_pulls_trst") == 0)
1884 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1885 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1886 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1887 else if (strcmp(args[1], "combined") == 0)
1888 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1889 else
1890 {
1891 LOG_ERROR("invalid reset_config argument, defaulting to none");
1892 jtag_reset_config = RESET_NONE;
1893 return ERROR_INVALID_ARGUMENTS;
1894 }
1895 }
1896 }
1897
1898 if (argc >= 3)
1899 {
1900 if (strcmp(args[2], "trst_open_drain") == 0)
1901 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1902 else if (strcmp(args[2], "trst_push_pull") == 0)
1903 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1904 else
1905 {
1906 LOG_ERROR("invalid reset_config argument, defaulting to none");
1907 jtag_reset_config = RESET_NONE;
1908 return ERROR_INVALID_ARGUMENTS;
1909 }
1910 }
1911
1912 if (argc >= 4)
1913 {
1914 if (strcmp(args[3], "srst_push_pull") == 0)
1915 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1916 else if (strcmp(args[3], "srst_open_drain") == 0)
1917 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1918 else
1919 {
1920 LOG_ERROR("invalid reset_config argument, defaulting to none");
1921 jtag_reset_config = RESET_NONE;
1922 return ERROR_INVALID_ARGUMENTS;
1923 }
1924 }
1925
1926 return ERROR_OK;
1927 }
1928
1929 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1930 {
1931 if (argc < 1)
1932 {
1933 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1934 exit(-1);
1935 }
1936 else
1937 {
1938 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1939 }
1940
1941 return ERROR_OK;
1942 }
1943
1944 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1945 {
1946 if (argc < 1)
1947 {
1948 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1949 exit(-1);
1950 }
1951 else
1952 {
1953 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1954 }
1955
1956 return ERROR_OK;
1957 }
1958
1959 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1960 {
1961 int retval=ERROR_OK;
1962
1963 if (argc == 1)
1964 {
1965 LOG_DEBUG("handle jtag speed");
1966
1967 int cur_speed = 0;
1968 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
1969
1970 /* this command can be called during CONFIG,
1971 * in which case jtag isn't initialized */
1972 if (jtag)
1973 {
1974 retval=jtag->speed(cur_speed);
1975 }
1976 } else if (argc == 0)
1977 {
1978 } else
1979 {
1980 return ERROR_COMMAND_SYNTAX_ERROR;
1981 }
1982 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
1983
1984 return retval;
1985 }
1986
1987 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1988 {
1989 int retval=ERROR_OK;
1990 LOG_DEBUG("handle jtag khz");
1991
1992 if(argc == 1)
1993 {
1994 speed_khz = strtoul(args[0], NULL, 0);
1995 if (jtag != NULL)
1996 {
1997 int cur_speed = 0;
1998 LOG_DEBUG("have interface set up");
1999 int speed_div1;
2000 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2001 {
2002 speed_khz = 0;
2003 return retval;
2004 }
2005
2006 cur_speed = jtag_speed = speed_div1;
2007
2008 retval=jtag->speed(cur_speed);
2009 } else
2010 {
2011 hasKHz = 1;
2012 }
2013 } else if (argc==0)
2014 {
2015 } else
2016 {
2017 return ERROR_COMMAND_SYNTAX_ERROR;
2018 }
2019
2020 if (jtag!=NULL)
2021 {
2022 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2023 return retval;
2024 }
2025
2026 if (speed_khz==0)
2027 {
2028 command_print(cmd_ctx, "RCLK - adaptive");
2029 } else
2030 {
2031 command_print(cmd_ctx, "%d kHz", speed_khz);
2032 }
2033 return retval;
2034
2035 }
2036
2037 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2038 {
2039 enum tap_state state;
2040
2041 if (argc < 1)
2042 {
2043 return ERROR_COMMAND_SYNTAX_ERROR;
2044 }
2045 else
2046 {
2047 for (state = 0; state < 16; state++)
2048 {
2049 if (strcmp(args[0], tap_state_strings[state]) == 0)
2050 {
2051 jtag_add_end_state(state);
2052 jtag_execute_queue();
2053 }
2054 }
2055 }
2056 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[cmd_queue_end_state]);
2057
2058 return ERROR_OK;
2059 }
2060
2061 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2062 {
2063 int trst = -1;
2064 int srst = -1;
2065
2066 if (argc < 2)
2067 {
2068 return ERROR_COMMAND_SYNTAX_ERROR;
2069 }
2070
2071 if (args[0][0] == '1')
2072 trst = 1;
2073 else if (args[0][0] == '0')
2074 trst = 0;
2075 else
2076 {
2077 return ERROR_COMMAND_SYNTAX_ERROR;
2078 }
2079
2080 if (args[1][0] == '1')
2081 srst = 1;
2082 else if (args[1][0] == '0')
2083 srst = 0;
2084 else
2085 {
2086 return ERROR_COMMAND_SYNTAX_ERROR;
2087 }
2088
2089 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2090 return ERROR_JTAG_INIT_FAILED;
2091
2092 jtag_add_reset(trst, srst);
2093 jtag_execute_queue();
2094
2095 return ERROR_OK;
2096 }
2097
2098 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2099 {
2100 if (argc < 1)
2101 {
2102 return ERROR_COMMAND_SYNTAX_ERROR;
2103 }
2104
2105 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
2106 jtag_execute_queue();
2107
2108 return ERROR_OK;
2109
2110 }
2111
2112 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2113 {
2114 int i;
2115 scan_field_t *fields;
2116
2117 if ((argc < 2) || (argc % 2))
2118 {
2119 return ERROR_COMMAND_SYNTAX_ERROR;
2120 }
2121
2122 fields = malloc(sizeof(scan_field_t) * argc / 2);
2123
2124 for (i = 0; i < argc / 2; i++)
2125 {
2126 int device = strtoul(args[i*2], NULL, 0);
2127 jtag_device_t *device_ptr=jtag_get_device(device);
2128 if (device_ptr==NULL)
2129 {
2130 return ERROR_FAIL;
2131 }
2132 int field_size = device_ptr->ir_length;
2133 fields[i].device = device;
2134 fields[i].out_value = malloc(CEIL(field_size, 8));
2135 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2136 fields[i].out_mask = NULL;
2137 fields[i].in_value = NULL;
2138 fields[i].in_check_mask = NULL;
2139 fields[i].in_handler = NULL;
2140 fields[i].in_handler_priv = NULL;
2141 }
2142
2143 jtag_add_ir_scan(argc / 2, fields, -1);
2144 jtag_execute_queue();
2145
2146 for (i = 0; i < argc / 2; i++)
2147 free(fields[i].out_value);
2148
2149 free (fields);
2150
2151 return ERROR_OK;
2152 }
2153
2154 int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2155 {
2156 int retval;
2157 scan_field_t *fields;
2158 int num_fields;
2159 int field_count = 0;
2160 int i, e;
2161 long device;
2162
2163 /* args[1] = device
2164 * args[2] = num_bits
2165 * args[3] = hex string
2166 * ... repeat num bits and hex string ...
2167 */
2168 if ((argc < 4) || ((argc % 2)!=0))
2169 {
2170 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2171 return JIM_ERR;
2172 }
2173
2174 for (i = 2; i < argc; i+=2)
2175 {
2176 long bits;
2177
2178 e = Jim_GetLong(interp, args[i], &bits);
2179 if (e != JIM_OK)
2180 return e;
2181 }
2182
2183 e = Jim_GetLong(interp, args[1], &device);
2184 if (e != JIM_OK)
2185 return e;
2186
2187 num_fields=(argc-2)/2;
2188 fields = malloc(sizeof(scan_field_t) * num_fields);
2189 for (i = 2; i < argc; i+=2)
2190 {
2191 long bits;
2192 int len;
2193 const char *str;
2194
2195 Jim_GetLong(interp, args[i], &bits);
2196 str = Jim_GetString(args[i+1], &len);
2197
2198 fields[field_count].device = device;
2199 fields[field_count].num_bits = bits;
2200 fields[field_count].out_value = malloc(CEIL(bits, 8));
2201 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2202 fields[field_count].out_mask = NULL;
2203 fields[field_count].in_value = fields[field_count].out_value;
2204 fields[field_count].in_check_mask = NULL;
2205 fields[field_count].in_check_value = NULL;
2206 fields[field_count].in_handler = NULL;
2207 fields[field_count++].in_handler_priv = NULL;
2208 }
2209
2210 jtag_add_dr_scan(num_fields, fields, -1);
2211 retval = jtag_execute_queue();
2212 if (retval != ERROR_OK)
2213 {
2214 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2215 Jim_AppendStrings(interp, Jim_GetResult(interp), "drscan: jtag execute failed", NULL);
2216 return JIM_ERR;
2217 }
2218
2219 field_count=0;
2220 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2221 for (i = 2; i < argc; i+=2)
2222 {
2223 long bits;
2224 char *str;
2225
2226 Jim_GetLong(interp, args[i], &bits);
2227 str = buf_to_str(fields[field_count].in_value, bits, 16);
2228 free(fields[field_count].out_value);
2229
2230 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2231 free(str);
2232 field_count++;
2233 }
2234
2235 Jim_SetResult(interp, list);
2236
2237 free(fields);
2238
2239 return JIM_OK;
2240 }
2241
2242 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2243 {
2244 if (argc == 1)
2245 {
2246 if (strcmp(args[0], "enable") == 0)
2247 {
2248 jtag_verify_capture_ir = 1;
2249 }
2250 else if (strcmp(args[0], "disable") == 0)
2251 {
2252 jtag_verify_capture_ir = 0;
2253 } else
2254 {
2255 return ERROR_COMMAND_SYNTAX_ERROR;
2256 }
2257 } else if (argc != 0)
2258 {
2259 return ERROR_COMMAND_SYNTAX_ERROR;
2260 }
2261
2262 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2263
2264 return ERROR_OK;
2265 }
2266
2267
2268 int jtag_power_dropout(int *dropout)
2269 {
2270 return jtag->power_dropout(dropout);
2271 }
2272
2273 int jtag_srst_asserted(int *srst_asserted)
2274 {
2275 return jtag->srst_asserted(srst_asserted);
2276 }
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)