Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
formatting.
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "replacements.h"
25
26 #include "jtag.h"
27
28 #include "command.h"
29 #include "log.h"
30 #include "interpreter.h"
31
32 #include "stdlib.h"
33 #include "string.h"
34 #include <unistd.h>
35
36 char* tap_state_strings[16] =
37 {
38 "tlr",
39 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
40 "rti",
41 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
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 * SD->SD and SI->SI have to be caught in interface specific code
63 */
64 u8 tap_move[6][6] =
65 {
66 /* TLR RTI SD PD SI PI */
67 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
68 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
69 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
70 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
71 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
72 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
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_TLR, TAP_RTI}, /* TLR */
83 {TAP_SIS, TAP_CD}, /* SDS */
84 {TAP_E1D, TAP_SD}, /* CD */
85 {TAP_E1D, TAP_SD}, /* SD */
86 {TAP_UD, TAP_PD}, /* E1D */
87 {TAP_E2D, TAP_PD}, /* PD */
88 {TAP_UD, TAP_SD}, /* E2D */
89 {TAP_SDS, TAP_RTI}, /* UD */
90 {TAP_SDS, TAP_RTI}, /* RTI */
91 {TAP_TLR, TAP_CI}, /* SIS */
92 {TAP_E1I, TAP_SI}, /* CI */
93 {TAP_E1I, TAP_SI}, /* SI */
94 {TAP_UI, TAP_PI}, /* E1I */
95 {TAP_E2I, TAP_PI}, /* PI */
96 {TAP_UI, TAP_SI}, /* E2I */
97 {TAP_SDS, TAP_RTI} /* UI */
98 };
99
100 char* jtag_event_strings[] =
101 {
102 "SRST asserted",
103 "TRST asserted",
104 "SRST released",
105 "TRST released"
106 };
107
108 enum tap_state end_state = TAP_TLR;
109 enum tap_state cur_state = TAP_TLR;
110 int jtag_trst = 0;
111 int jtag_srst = 0;
112
113 jtag_command_t *jtag_command_queue = NULL;
114 jtag_command_t **last_comand_pointer = &jtag_command_queue;
115 jtag_device_t *jtag_devices = NULL;
116 int jtag_num_devices = 0;
117 int jtag_ir_scan_size = 0;
118 enum reset_types jtag_reset_config = RESET_NONE;
119 enum tap_state cmd_queue_end_state = TAP_TLR;
120 enum tap_state cmd_queue_cur_state = TAP_TLR;
121
122 int jtag_verify_capture_ir = 1;
123
124 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
125 int jtag_nsrst_delay = 0; /* default to no nSRST delay */
126 int jtag_ntrst_delay = 0; /* default to no nTRST delay */
127
128 /* maximum number of JTAG devices expected in the chain
129 */
130 #define JTAG_MAX_CHAIN_SIZE 20
131
132 /* callbacks to inform high-level handlers about JTAG state changes */
133 jtag_event_callback_t *jtag_event_callbacks;
134
135 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
136 */
137 #if BUILD_PARPORT == 1
138 extern jtag_interface_t parport_interface;
139 #endif
140
141 #if BUILD_FT2232_FTD2XX == 1
142 extern jtag_interface_t ft2232_interface;
143 #endif
144
145 #if BUILD_FT2232_LIBFTDI == 1
146 extern jtag_interface_t ft2232_interface;
147 #endif
148
149 #if BUILD_AMTJTAGACCEL == 1
150 extern jtag_interface_t amt_jtagaccel_interface;
151 #endif
152
153 #if BUILD_EP93XX == 1
154 extern jtag_interface_t ep93xx_interface;
155 #endif
156
157 #if BUILD_AT91RM9200 == 1
158 extern jtag_interface_t at91rm9200_interface;
159 #endif
160
161 #if BUILD_GW16012 == 1
162 extern jtag_interface_t gw16012_interface;
163 #endif
164
165 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
166 extern jtag_interface_t presto_interface;
167 #endif
168
169 #if BUILD_USBPROG == 1
170 extern jtag_interface_t usbprog_interface;
171 #endif
172
173 jtag_interface_t *jtag_interfaces[] = {
174 #if BUILD_PARPORT == 1
175 &parport_interface,
176 #endif
177 #if BUILD_FT2232_FTD2XX == 1
178 &ft2232_interface,
179 #endif
180 #if BUILD_FT2232_LIBFTDI == 1
181 &ft2232_interface,
182 #endif
183 #if BUILD_AMTJTAGACCEL == 1
184 &amt_jtagaccel_interface,
185 #endif
186 #if BUILD_EP93XX == 1
187 &ep93xx_interface,
188 #endif
189 #if BUILD_AT91RM9200 == 1
190 &at91rm9200_interface,
191 #endif
192 #if BUILD_GW16012 == 1
193 &gw16012_interface,
194 #endif
195 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
196 &presto_interface,
197 #endif
198 #if BUILD_USBPROG == 1
199 &usbprog_interface,
200 #endif
201 NULL,
202 };
203
204 jtag_interface_t *jtag = NULL;
205
206 /* configuration */
207 jtag_interface_t *jtag_interface = NULL;
208 int jtag_speed = 0;
209
210
211 /* forward declarations */
212 int jtag_add_statemove(enum tap_state endstate);
213 int jtag_add_pathmove(int num_states, enum tap_state *path);
214 int jtag_add_runtest(int num_cycles, enum tap_state endstate);
215 int jtag_add_reset(int trst, int srst);
216 int jtag_add_end_state(enum tap_state endstate);
217 int jtag_add_sleep(u32 us);
218 int jtag_execute_queue(void);
219 int jtag_cancel_queue(void);
220
221 /* jtag commands */
222 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
223 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
224 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
225 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
226 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
227 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
228
229 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
230
231 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
232 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
233 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
234 int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
235 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237
238 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239
240 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
241 {
242 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
243
244 if (callback == NULL)
245 {
246 return ERROR_INVALID_ARGUMENTS;
247 }
248
249 if (*callbacks_p)
250 {
251 while ((*callbacks_p)->next)
252 callbacks_p = &((*callbacks_p)->next);
253 callbacks_p = &((*callbacks_p)->next);
254 }
255
256 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
257 (*callbacks_p)->callback = callback;
258 (*callbacks_p)->priv = priv;
259 (*callbacks_p)->next = NULL;
260
261 return ERROR_OK;
262 }
263
264 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
265 {
266 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
267
268 if (callback == NULL)
269 {
270 return ERROR_INVALID_ARGUMENTS;
271 }
272
273 while (*callbacks_p)
274 {
275 jtag_event_callback_t **next = &((*callbacks_p)->next);
276 if ((*callbacks_p)->callback == callback)
277 {
278 free(*callbacks_p);
279 *callbacks_p = *next;
280 }
281 callbacks_p = next;
282 }
283
284 return ERROR_OK;
285 }
286
287 int jtag_call_event_callbacks(enum jtag_event event)
288 {
289 jtag_event_callback_t *callback = jtag_event_callbacks;
290
291 DEBUG("jtag event: %s", jtag_event_strings[event]);
292
293 while (callback)
294 {
295 callback->callback(event, callback->priv);
296 callback = callback->next;
297 }
298
299 return ERROR_OK;
300 }
301
302 /* returns a pointer to the pointer of the last command in queue
303 * this may be a pointer to the root pointer (jtag_command_queue)
304 * or to the next member of the last but one command
305 */
306 jtag_command_t** jtag_get_last_command_p(void)
307 {
308 /* jtag_command_t *cmd = jtag_command_queue;
309
310 if (cmd)
311 while (cmd->next)
312 cmd = cmd->next;
313 else
314 return &jtag_command_queue;
315
316 return &cmd->next;*/
317
318 return last_comand_pointer;
319 }
320
321 /* returns a pointer to the n-th device in the scan chain */
322 jtag_device_t* jtag_get_device(int num)
323 {
324 jtag_device_t *device = jtag_devices;
325 int i = 0;
326
327 while (device)
328 {
329 if (num == i)
330 return device;
331 device = device->next;
332 i++;
333 }
334
335 ERROR("jtag device number %d not defined", num);
336 exit(-1);
337 }
338
339 void* cmd_queue_alloc(size_t size)
340 {
341 cmd_queue_page_t **p_page = &cmd_queue_pages;
342 int offset;
343
344 if (*p_page)
345 {
346 while ((*p_page)->next)
347 p_page = &((*p_page)->next);
348 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
349 p_page = &((*p_page)->next);
350 }
351
352 if (!*p_page)
353 {
354 *p_page = malloc(sizeof(cmd_queue_page_t));
355 (*p_page)->used = 0;
356 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
357 (*p_page)->next = NULL;
358 }
359
360 offset = (*p_page)->used;
361 (*p_page)->used += size;
362
363 u8 *t=(u8 *)((*p_page)->address);
364 return t + offset;
365 }
366
367 void cmd_queue_free()
368 {
369 cmd_queue_page_t *page = cmd_queue_pages;
370
371 while (page)
372 {
373 cmd_queue_page_t *last = page;
374 free(page->address);
375 page = page->next;
376 free(last);
377 }
378
379 cmd_queue_pages = NULL;
380 }
381
382 int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
383 {
384 jtag_command_t **last_cmd;
385 jtag_device_t *device;
386 int i, j;
387 int scan_size = 0;
388
389 if (jtag_trst == 1)
390 {
391 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
392 return ERROR_JTAG_TRST_ASSERTED;
393 }
394
395 last_cmd = jtag_get_last_command_p();
396
397 /* allocate memory for a new list member */
398 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
399 (*last_cmd)->next = NULL;
400 last_comand_pointer = &((*last_cmd)->next);
401 (*last_cmd)->type = JTAG_SCAN;
402
403 /* allocate memory for ir scan command */
404 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
405 (*last_cmd)->cmd.scan->ir_scan = 1;
406 (*last_cmd)->cmd.scan->num_fields = jtag_num_devices; /* one field per device */
407 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(jtag_num_devices * sizeof(scan_field_t));
408 (*last_cmd)->cmd.scan->end_state = state;
409
410 if (state != -1)
411 cmd_queue_end_state = state;
412
413 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
414 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
415
416 if (cmd_queue_end_state == TAP_TLR)
417 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
418
419 cmd_queue_cur_state = cmd_queue_end_state;
420
421 for (i = 0; i < jtag_num_devices; i++)
422 {
423 int found = 0;
424 device = jtag_get_device(i);
425 scan_size = device->ir_length;
426 (*last_cmd)->cmd.scan->fields[i].device = i;
427 (*last_cmd)->cmd.scan->fields[i].num_bits = scan_size;
428 (*last_cmd)->cmd.scan->fields[i].in_value = NULL;
429 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; /* disable verification by default */
430
431 /* search the list */
432 for (j = 0; j < num_fields; j++)
433 {
434 if (i == fields[j].device)
435 {
436 found = 1;
437 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
438 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
439
440 if (jtag_verify_capture_ir)
441 {
442 if (fields[j].in_handler==NULL)
443 {
444 jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL);
445 } else
446 {
447 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler;
448 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv;
449 (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected;
450 (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask;
451 }
452 }
453
454 device->bypass = 0;
455 break;
456 }
457 }
458
459 if (!found)
460 {
461 /* if a device isn't listed, set it to BYPASS */
462 (*last_cmd)->cmd.scan->fields[i].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
463 (*last_cmd)->cmd.scan->fields[i].out_mask = NULL;
464 device->bypass = 1;
465
466 }
467
468 /* update device information */
469 buf_cpy((*last_cmd)->cmd.scan->fields[i].out_value, jtag_get_device(i)->cur_instr, scan_size);
470 }
471
472 return ERROR_OK;
473 }
474
475 int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
476 {
477 jtag_command_t **last_cmd;
478 int i;
479
480 if (jtag_trst == 1)
481 {
482 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
483 return ERROR_JTAG_TRST_ASSERTED;
484 }
485
486 last_cmd = jtag_get_last_command_p();
487
488 /* allocate memory for a new list member */
489 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
490 (*last_cmd)->next = NULL;
491 last_comand_pointer = &((*last_cmd)->next);
492 (*last_cmd)->type = JTAG_SCAN;
493
494 /* allocate memory for ir scan command */
495 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
496 (*last_cmd)->cmd.scan->ir_scan = 1;
497 (*last_cmd)->cmd.scan->num_fields = num_fields;
498 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
499 (*last_cmd)->cmd.scan->end_state = state;
500
501 if (state != -1)
502 cmd_queue_end_state = state;
503
504 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
505 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
506
507 if (cmd_queue_end_state == TAP_TLR)
508 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
509
510 cmd_queue_cur_state = cmd_queue_end_state;
511
512 for (i = 0; i < num_fields; i++)
513 {
514 int num_bits = fields[i].num_bits;
515 int num_bytes = CEIL(fields[i].num_bits, 8);
516 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
517 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
518 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
519 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
520 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
521 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
522 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
523 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
524 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
525 }
526 return ERROR_OK;
527 }
528
529 int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
530 {
531 int i, j;
532 int bypass_devices = 0;
533 int field_count = 0;
534 jtag_command_t **last_cmd = jtag_get_last_command_p();
535 jtag_device_t *device = jtag_devices;
536 int scan_size;
537
538 if (jtag_trst == 1)
539 {
540 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
541 return ERROR_JTAG_TRST_ASSERTED;
542 }
543
544 /* count devices in bypass */
545 while (device)
546 {
547 if (device->bypass)
548 bypass_devices++;
549 device = device->next;
550 }
551
552 /* allocate memory for a new list member */
553 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
554 last_comand_pointer = &((*last_cmd)->next);
555 (*last_cmd)->next = NULL;
556 (*last_cmd)->type = JTAG_SCAN;
557
558 /* allocate memory for dr scan command */
559 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
560 (*last_cmd)->cmd.scan->ir_scan = 0;
561 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
562 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
563 (*last_cmd)->cmd.scan->end_state = state;
564
565 if (state != -1)
566 cmd_queue_end_state = state;
567
568 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
569 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
570
571 if (cmd_queue_end_state == TAP_TLR)
572 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
573
574 cmd_queue_cur_state = cmd_queue_end_state;
575
576 for (i = 0; i < jtag_num_devices; i++)
577 {
578 int found = 0;
579 (*last_cmd)->cmd.scan->fields[field_count].device = i;
580
581 for (j = 0; j < num_fields; j++)
582 {
583 if (i == fields[j].device)
584 {
585 found = 1;
586 scan_size = fields[j].num_bits;
587 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
588 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
589 (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
590 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
591 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
592 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
593 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
594 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
595 }
596 }
597 if (!found)
598 {
599 /* if a device isn't listed, the BYPASS register should be selected */
600 if (!jtag_get_device(i)->bypass)
601 {
602 ERROR("BUG: no scan data for a device not in BYPASS");
603 exit(-1);
604 }
605
606 /* program the scan field to 1 bit length, and ignore it's value */
607 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
608 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
609 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
610 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
611 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
612 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
613 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
614 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
615 }
616 else
617 {
618 /* if a device is listed, the BYPASS register must not be selected */
619 if (jtag_get_device(i)->bypass)
620 {
621 WARNING("scan data for a device in BYPASS");
622 }
623 }
624 }
625 return ERROR_OK;
626 }
627
628
629 int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
630 {
631 int i;
632 jtag_command_t **last_cmd = jtag_get_last_command_p();
633
634 if (jtag_trst == 1)
635 {
636 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
637 return ERROR_JTAG_TRST_ASSERTED;
638 }
639
640 /* allocate memory for a new list member */
641 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
642 last_comand_pointer = &((*last_cmd)->next);
643 (*last_cmd)->next = NULL;
644 (*last_cmd)->type = JTAG_SCAN;
645
646 /* allocate memory for scan command */
647 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
648 (*last_cmd)->cmd.scan->ir_scan = 0;
649 (*last_cmd)->cmd.scan->num_fields = num_fields;
650 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
651 (*last_cmd)->cmd.scan->end_state = state;
652
653 if (state != -1)
654 cmd_queue_end_state = state;
655
656 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
657 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
658
659 if (cmd_queue_end_state == TAP_TLR)
660 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
661
662 cmd_queue_cur_state = cmd_queue_end_state;
663
664 for (i = 0; i < num_fields; i++)
665 {
666 int num_bits = fields[i].num_bits;
667 int num_bytes = CEIL(fields[i].num_bits, 8);
668 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
669 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
670 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
671 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
672 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
673 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
674 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
675 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
676 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
677 }
678
679 return ERROR_OK;
680 }
681 int jtag_add_statemove(enum tap_state state)
682 {
683 jtag_command_t **last_cmd = jtag_get_last_command_p();
684
685 if (jtag_trst == 1)
686 {
687 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
688 return ERROR_JTAG_TRST_ASSERTED;
689 }
690
691 /* allocate memory for a new list member */
692 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
693 last_comand_pointer = &((*last_cmd)->next);
694 (*last_cmd)->next = NULL;
695 (*last_cmd)->type = JTAG_STATEMOVE;
696
697 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
698 (*last_cmd)->cmd.statemove->end_state = state;
699
700 if (state != -1)
701 cmd_queue_end_state = state;
702
703 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
704 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
705
706 if (cmd_queue_end_state == TAP_TLR)
707 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
708
709 cmd_queue_cur_state = cmd_queue_end_state;
710
711 return ERROR_OK;
712 }
713
714 int jtag_add_pathmove(int num_states, enum tap_state *path)
715 {
716 jtag_command_t **last_cmd = jtag_get_last_command_p();
717 int i;
718
719 if (jtag_trst == 1)
720 {
721 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
722 return ERROR_JTAG_TRST_ASSERTED;
723 }
724
725 /* the last state has to be a stable state */
726 if (tap_move_map[path[num_states - 1]] == -1)
727 {
728 ERROR("TAP path doesn't finish in a stable state");
729 return ERROR_JTAG_NOT_IMPLEMENTED;
730 }
731
732 /* allocate memory for a new list member */
733 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
734 last_comand_pointer = &((*last_cmd)->next);
735 (*last_cmd)->next = NULL;
736 (*last_cmd)->type = JTAG_PATHMOVE;
737
738 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
739 (*last_cmd)->cmd.pathmove->num_states = num_states;
740 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states);
741
742 for (i = 0; i < num_states; i++)
743 (*last_cmd)->cmd.pathmove->path[i] = path[i];
744
745 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
746 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
747
748 if (cmd_queue_end_state == TAP_TLR)
749 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
750
751 cmd_queue_cur_state = path[num_states - 1];
752
753 return ERROR_OK;
754 }
755
756 int jtag_add_runtest(int num_cycles, enum tap_state state)
757 {
758 jtag_command_t **last_cmd = jtag_get_last_command_p();
759
760 if (jtag_trst == 1)
761 {
762 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
763 return ERROR_JTAG_TRST_ASSERTED;
764 }
765
766 /* allocate memory for a new list member */
767 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
768 (*last_cmd)->next = NULL;
769 last_comand_pointer = &((*last_cmd)->next);
770 (*last_cmd)->type = JTAG_RUNTEST;
771
772 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
773 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
774 (*last_cmd)->cmd.runtest->end_state = state;
775
776 if (state != -1)
777 cmd_queue_end_state = state;
778
779 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
780 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
781
782 if (cmd_queue_end_state == TAP_TLR)
783 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
784
785 cmd_queue_cur_state = cmd_queue_end_state;
786
787 return ERROR_OK;
788 }
789
790 int jtag_add_reset(int req_trst, int req_srst)
791 {
792 int trst_with_tms = 0;
793
794 jtag_command_t **last_cmd = jtag_get_last_command_p();
795
796 if (req_trst == -1)
797 req_trst = jtag_trst;
798
799 if (req_srst == -1)
800 req_srst = jtag_srst;
801
802 /* Make sure that jtag_reset_config allows the requested reset */
803 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
804 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (req_trst == 0))
805 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST;
806
807 /* if TRST pulls SRST, we reset with TAP T-L-R */
808 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_trst == 1)) && (req_srst == 0))
809 {
810 req_trst = 0;
811 trst_with_tms = 1;
812 }
813
814 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
815 {
816 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
817 return ERROR_JTAG_RESET_CANT_SRST;
818 }
819
820 if (req_trst && !(jtag_reset_config & RESET_HAS_TRST))
821 {
822 req_trst = 0;
823 trst_with_tms = 1;
824 }
825
826 /* allocate memory for a new list member */
827 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
828 (*last_cmd)->next = NULL;
829 last_comand_pointer = &((*last_cmd)->next);
830 (*last_cmd)->type = JTAG_RESET;
831
832 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
833 (*last_cmd)->cmd.reset->trst = req_trst;
834 (*last_cmd)->cmd.reset->srst = req_srst;
835
836 jtag_trst = req_trst;
837 jtag_srst = req_srst;
838
839 if (jtag_srst)
840 {
841 jtag_call_event_callbacks(JTAG_SRST_ASSERTED);
842 }
843 else
844 {
845 jtag_call_event_callbacks(JTAG_SRST_RELEASED);
846 if (jtag_nsrst_delay)
847 jtag_add_sleep(jtag_nsrst_delay * 1000);
848 }
849
850 if (trst_with_tms)
851 {
852 last_cmd = &((*last_cmd)->next);
853
854 /* allocate memory for a new list member */
855 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
856 (*last_cmd)->next = NULL;
857 last_comand_pointer = &((*last_cmd)->next);
858 (*last_cmd)->type = JTAG_STATEMOVE;
859
860 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
861 (*last_cmd)->cmd.statemove->end_state = TAP_TLR;
862
863 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
864 cmd_queue_cur_state = TAP_TLR;
865 cmd_queue_end_state = TAP_TLR;
866
867 return ERROR_OK;
868 }
869 else
870 {
871 if (jtag_trst)
872 {
873 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
874 * and inform possible listeners about this
875 */
876 cmd_queue_cur_state = TAP_TLR;
877 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
878 }
879 else
880 {
881 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
882 * but we might want to add a delay to give the TAP time to settle
883 */
884 if (jtag_ntrst_delay)
885 jtag_add_sleep(jtag_ntrst_delay * 1000);
886 }
887 }
888
889 return ERROR_OK;
890 }
891
892 int jtag_add_end_state(enum tap_state state)
893 {
894 jtag_command_t **last_cmd = jtag_get_last_command_p();
895
896 /* allocate memory for a new list member */
897 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
898 (*last_cmd)->next = NULL;
899 last_comand_pointer = &((*last_cmd)->next);
900 (*last_cmd)->type = JTAG_END_STATE;
901
902 (*last_cmd)->cmd.end_state = cmd_queue_alloc(sizeof(end_state_command_t));
903 (*last_cmd)->cmd.end_state->end_state = state;
904
905 if (state != -1)
906 cmd_queue_end_state = state;
907
908 return ERROR_OK;
909 }
910
911 int jtag_add_sleep(u32 us)
912 {
913 jtag_command_t **last_cmd = jtag_get_last_command_p();
914
915 /* allocate memory for a new list member */
916 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
917 (*last_cmd)->next = NULL;
918 last_comand_pointer = &((*last_cmd)->next);
919 (*last_cmd)->type = JTAG_SLEEP;
920
921 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
922 (*last_cmd)->cmd.sleep->us = us;
923
924 return ERROR_OK;
925 }
926
927 int jtag_scan_size(scan_command_t *cmd)
928 {
929 int bit_count = 0;
930 int i;
931
932 /* count bits in scan command */
933 for (i = 0; i < cmd->num_fields; i++)
934 {
935 bit_count += cmd->fields[i].num_bits;
936 }
937
938 return bit_count;
939 }
940
941 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
942 {
943 int bit_count = 0;
944 int i;
945
946 bit_count = jtag_scan_size(cmd);
947 *buffer = malloc(CEIL(bit_count, 8));
948
949 bit_count = 0;
950
951 for (i = 0; i < cmd->num_fields; i++)
952 {
953 if (cmd->fields[i].out_value)
954 {
955 #ifdef _DEBUG_JTAG_IO_
956 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16);
957 #endif
958 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
959 #ifdef _DEBUG_JTAG_IO_
960 DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
961 free(char_buf);
962 #endif
963 }
964
965 bit_count += cmd->fields[i].num_bits;
966 }
967
968 return bit_count;
969
970 }
971
972 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
973 {
974 int i;
975 int bit_count = 0;
976 int retval;
977
978 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
979 retval = ERROR_OK;
980
981 for (i = 0; i < cmd->num_fields; i++)
982 {
983 /* if neither in_value nor in_handler
984 * are specified we don't have to examine this field
985 */
986 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
987 {
988 int num_bits = cmd->fields[i].num_bits;
989 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
990
991 #ifdef _DEBUG_JTAG_IO_
992 char *char_buf;
993
994 char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
995 DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
996 free(char_buf);
997 #endif
998
999 if (cmd->fields[i].in_value)
1000 {
1001 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1002
1003 if (cmd->fields[i].in_handler)
1004 {
1005 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1006 {
1007 WARNING("in_handler reported a failed check");
1008 retval = ERROR_JTAG_QUEUE_FAILED;
1009 }
1010 }
1011 }
1012
1013 /* no in_value specified, but a handler takes care of the scanned data */
1014 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1015 {
1016 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1017 {
1018 /* We're going to call the error:handler later, but if the in_handler
1019 * reported an error we report this failure upstream
1020 */
1021 WARNING("in_handler reported a failed check");
1022 retval = ERROR_JTAG_QUEUE_FAILED;
1023 }
1024 }
1025
1026 free(captured);
1027 }
1028 bit_count += cmd->fields[i].num_bits;
1029 }
1030
1031 return retval;
1032 }
1033
1034 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1035 {
1036 int retval = ERROR_OK;
1037 int num_bits = field->num_bits;
1038
1039 int compare_failed = 0;
1040
1041 if (field->in_check_mask)
1042 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1043 else
1044 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1045
1046 if (compare_failed)
1047 {
1048 /* An error handler could have caught the failing check
1049 * only report a problem when there wasn't a handler, or if the handler
1050 * acknowledged the error
1051 */
1052 if (compare_failed)
1053 {
1054 char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1055 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16);
1056
1057 if (field->in_check_mask)
1058 {
1059 char *in_check_mask_char;
1060 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16);
1061 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);
1062 free(in_check_mask_char);
1063 }
1064 else
1065 {
1066 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char);
1067 }
1068
1069 free(captured_char);
1070 free(in_check_value_char);
1071
1072 retval = ERROR_JTAG_QUEUE_FAILED;
1073 }
1074
1075 }
1076 return retval;
1077 }
1078
1079 /*
1080 set up checking of this field using the in_handler. The values passed in must be valid until
1081 after jtag_execute() has completed.
1082 */
1083 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1084 {
1085 if (value)
1086 field->in_handler = jtag_check_value;
1087 else
1088 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1089 field->in_handler_priv = NULL; /* this will be filled in at the invocation site to point to the field duplicate */
1090 field->in_check_value = value;
1091 field->in_check_mask = mask;
1092 }
1093
1094 enum scan_type jtag_scan_type(scan_command_t *cmd)
1095 {
1096 int i;
1097 int type = 0;
1098
1099 for (i = 0; i < cmd->num_fields; i++)
1100 {
1101 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1102 type |= SCAN_IN;
1103 if (cmd->fields[i].out_value)
1104 type |= SCAN_OUT;
1105 }
1106
1107 return type;
1108 }
1109
1110 int jtag_execute_queue(void)
1111 {
1112 int retval;
1113
1114 retval = jtag->execute_queue();
1115
1116 cmd_queue_free();
1117
1118 jtag_command_queue = NULL;
1119 last_comand_pointer = &jtag_command_queue;
1120
1121 return retval;
1122 }
1123
1124 int jtag_reset_callback(enum jtag_event event, void *priv)
1125 {
1126 jtag_device_t *device = priv;
1127
1128 DEBUG("-");
1129
1130 if (event == JTAG_TRST_ASSERTED)
1131 {
1132 buf_set_ones(device->cur_instr, device->ir_length);
1133 device->bypass = 1;
1134 }
1135
1136 return ERROR_OK;
1137 }
1138
1139 void jtag_sleep(u32 us)
1140 {
1141 usleep(us);
1142 }
1143
1144 /* Try to examine chain layout according to IEEE 1149.1 §12
1145 */
1146 int jtag_examine_chain()
1147 {
1148 jtag_device_t *device = jtag_devices;
1149 scan_field_t field;
1150 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1151 int i;
1152 int bit_count;
1153 int device_count = 0;
1154 u8 zero_check = 0x0;
1155 u8 one_check = 0xff;
1156
1157 field.device = 0;
1158 field.num_bits = sizeof(idcode_buffer) * 8;
1159 field.out_value = idcode_buffer;
1160 field.out_mask = NULL;
1161 field.in_value = idcode_buffer;
1162 field.in_check_value = NULL;
1163 field.in_check_mask = NULL;
1164 field.in_handler = NULL;
1165 field.in_handler_priv = NULL;
1166
1167 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1168 {
1169 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1170 }
1171
1172 jtag_add_plain_dr_scan(1, &field, TAP_TLR);
1173 jtag_execute_queue();
1174
1175 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1176 {
1177 zero_check |= idcode_buffer[i];
1178 one_check &= idcode_buffer[i];
1179 }
1180
1181 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1182 if ((zero_check == 0x00) || (one_check == 0xff))
1183 {
1184 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1185 return ERROR_JTAG_INIT_FAILED;
1186 }
1187
1188 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1189 {
1190 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1191 if ((idcode & 1) == 0)
1192 {
1193 /* LSB must not be 0, this indicates a device in bypass */
1194 device_count++;
1195
1196 bit_count += 1;
1197 }
1198 else
1199 {
1200 u32 manufacturer;
1201 u32 part;
1202 u32 version;
1203
1204 if (idcode == 0x000000FF)
1205 {
1206 /* End of chain (invalid manufacturer ID) */
1207 break;
1208 }
1209
1210 if (device)
1211 {
1212 device->idcode = idcode;
1213 device = device->next;
1214 }
1215 device_count++;
1216
1217 manufacturer = (idcode & 0xffe) >> 1;
1218 part = (idcode & 0xffff000) >> 12;
1219 version = (idcode & 0xf0000000) >> 28;
1220
1221 INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1222 idcode, manufacturer, part, version);
1223
1224 bit_count += 32;
1225 }
1226 }
1227
1228 /* see if number of discovered devices matches configuration */
1229 if (device_count != jtag_num_devices)
1230 {
1231 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1232 device_count, jtag_num_devices);
1233 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1234 return ERROR_JTAG_INIT_FAILED;
1235 }
1236
1237 return ERROR_OK;
1238 }
1239
1240 int jtag_validate_chain()
1241 {
1242 jtag_device_t *device = jtag_devices;
1243 int total_ir_length = 0;
1244 u8 *ir_test = NULL;
1245 scan_field_t field;
1246 int chain_pos = 0;
1247
1248 while (device)
1249 {
1250 total_ir_length += device->ir_length;
1251 device = device->next;
1252 }
1253
1254 total_ir_length += 2;
1255 ir_test = malloc(CEIL(total_ir_length, 8));
1256 buf_set_ones(ir_test, total_ir_length);
1257
1258 field.device = 0;
1259 field.num_bits = total_ir_length;
1260 field.out_value = ir_test;
1261 field.out_mask = NULL;
1262 field.in_value = ir_test;
1263 field.in_check_value = NULL;
1264 field.in_check_mask = NULL;
1265 field.in_handler = NULL;
1266 field.in_handler_priv = NULL;
1267
1268 jtag_add_plain_ir_scan(1, &field, TAP_TLR);
1269 jtag_execute_queue();
1270
1271 device = jtag_devices;
1272 while (device)
1273 {
1274 if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
1275 {
1276 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1277 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1278 free(cbuf);
1279 free(ir_test);
1280 return ERROR_JTAG_INIT_FAILED;
1281 }
1282 chain_pos += device->ir_length;
1283 device = device->next;
1284 }
1285
1286 if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
1287 {
1288 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1289 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1290 free(cbuf);
1291 free(ir_test);
1292 return ERROR_JTAG_INIT_FAILED;
1293 }
1294
1295 free(ir_test);
1296
1297 return ERROR_OK;
1298 }
1299
1300 int jtag_register_commands(struct command_context_s *cmd_ctx)
1301 {
1302 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1303 COMMAND_CONFIG, NULL);
1304 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1305 COMMAND_ANY, "set jtag speed (if supported) <speed>");
1306 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1307 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1308 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1309 COMMAND_CONFIG, NULL);
1310 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1311 COMMAND_CONFIG, NULL);
1312 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1313 COMMAND_CONFIG, NULL);
1314
1315 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1316 COMMAND_EXEC, "print current scan chain configuration");
1317
1318 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1319 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1320 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1321 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1322 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1323 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1324 register_command(cmd_ctx, NULL, "statemove", handle_statemove_command,
1325 COMMAND_EXEC, "move to current endstate or [tap_state]");
1326 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1327 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1328 register_command(cmd_ctx, NULL, "drscan", handle_drscan_command,
1329 COMMAND_EXEC, "execute DR scan <device> <var> [dev2] [var2] ...");
1330
1331 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1332 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1333 return ERROR_OK;
1334 }
1335
1336 int jtag_interface_init(struct command_context_s *cmd_ctx)
1337 {
1338 if (!jtag_interface)
1339 {
1340 /* nothing was previously specified by "interface" command */
1341 ERROR("JTAG interface has to be specified, see \"interface\" command");
1342 return ERROR_JTAG_INVALID_INTERFACE;
1343 }
1344
1345 if (jtag_interface->init() != ERROR_OK)
1346 return ERROR_JTAG_INIT_FAILED;
1347
1348 jtag = jtag_interface;
1349 return ERROR_OK;
1350 }
1351
1352 int jtag_init(struct command_context_s *cmd_ctx)
1353 {
1354 int i, validate_tries = 0;
1355 jtag_device_t *device;
1356
1357 DEBUG("-");
1358
1359 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1360 return ERROR_JTAG_INIT_FAILED;
1361
1362 device = jtag_devices;
1363 jtag_ir_scan_size = 0;
1364 jtag_num_devices = 0;
1365 while (device != NULL)
1366 {
1367 jtag_ir_scan_size += device->ir_length;
1368 jtag_num_devices++;
1369 device = device->next;
1370 }
1371
1372 jtag_add_statemove(TAP_TLR);
1373 jtag_execute_queue();
1374
1375 /* examine chain first, as this could discover the real chain layout */
1376 if (jtag_examine_chain() != ERROR_OK)
1377 {
1378 ERROR("trying to validate configured JTAG chain anyway...");
1379 }
1380
1381 while (jtag_validate_chain() != ERROR_OK)
1382 {
1383 validate_tries++;
1384 if (validate_tries > 5)
1385 {
1386 ERROR("Could not validate JTAG chain, exit");
1387 jtag = NULL;
1388 return ERROR_JTAG_INVALID_INTERFACE;
1389 }
1390 usleep(10000);
1391 }
1392
1393 return ERROR_OK;
1394 }
1395
1396 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1397 {
1398 int i;
1399
1400 /* check whether the interface is already configured */
1401 if (jtag_interface)
1402 {
1403 WARNING("Interface already configured, ignoring");
1404 return ERROR_OK;
1405 }
1406
1407 /* interface name is a mandatory argument */
1408 if (argc < 1 || args[0][0] == '\0')
1409 {
1410 return ERROR_COMMAND_SYNTAX_ERROR;
1411 }
1412
1413 for (i=0; jtag_interfaces[i]; i++)
1414 {
1415 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1416 {
1417 if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK)
1418 exit(-1);
1419
1420 jtag_interface = jtag_interfaces[i];
1421 return ERROR_OK;
1422 }
1423 }
1424
1425 /* no valid interface was found (i.e. the configuration option,
1426 * didn't match one of the compiled-in interfaces
1427 */
1428 ERROR("No valid jtag interface found (%s)", args[0]);
1429 ERROR("compiled-in jtag interfaces:");
1430 for (i = 0; jtag_interfaces[i]; i++)
1431 {
1432 ERROR("%i: %s", i, jtag_interfaces[i]->name);
1433 }
1434
1435 return ERROR_JTAG_INVALID_INTERFACE;
1436 }
1437
1438 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1439 {
1440 jtag_device_t **last_device_p = &jtag_devices;
1441
1442 if (*last_device_p)
1443 {
1444 while ((*last_device_p)->next)
1445 last_device_p = &((*last_device_p)->next);
1446 last_device_p = &((*last_device_p)->next);
1447 }
1448
1449 if (argc < 3)
1450 return ERROR_OK;
1451
1452 *last_device_p = malloc(sizeof(jtag_device_t));
1453 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1454
1455 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1456 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1457 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1458 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1459
1460 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1461 (*last_device_p)->bypass = 1;
1462 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1463
1464 (*last_device_p)->next = NULL;
1465
1466 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1467
1468 jtag_num_devices++;
1469
1470 return ERROR_OK;
1471 }
1472
1473 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1474 {
1475 jtag_device_t *device = jtag_devices;
1476 int device_count = 0;
1477
1478 while (device)
1479 {
1480 u32 expected, expected_mask, cur_instr;
1481 expected = buf_get_u32(device->expected, 0, device->ir_length);
1482 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1483 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1484 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);
1485 device = device->next;
1486 device_count++;
1487 }
1488
1489 return ERROR_OK;
1490 }
1491
1492 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1493 {
1494 if (argc >= 1)
1495 {
1496 if (strcmp(args[0], "none") == 0)
1497 jtag_reset_config = RESET_NONE;
1498 else if (strcmp(args[0], "trst_only") == 0)
1499 jtag_reset_config = RESET_HAS_TRST;
1500 else if (strcmp(args[0], "srst_only") == 0)
1501 jtag_reset_config = RESET_HAS_SRST;
1502 else if (strcmp(args[0], "trst_and_srst") == 0)
1503 jtag_reset_config = RESET_TRST_AND_SRST;
1504 else
1505 {
1506 ERROR("invalid reset_config argument, defaulting to none");
1507 jtag_reset_config = RESET_NONE;
1508 return ERROR_INVALID_ARGUMENTS;
1509 }
1510 }
1511
1512 if (argc >= 2)
1513 {
1514 if (strcmp(args[1], "srst_pulls_trst") == 0)
1515 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1516 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1517 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1518 else if (strcmp(args[1], "combined") == 0)
1519 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1520 else if (strcmp(args[1], "separate") == 0)
1521 jtag_reset_config &= ~(RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST);
1522 else
1523 {
1524 ERROR("invalid reset_config argument, defaulting to none");
1525 jtag_reset_config = RESET_NONE;
1526 return ERROR_INVALID_ARGUMENTS;
1527 }
1528 }
1529
1530 if (argc >= 3)
1531 {
1532 if (strcmp(args[2], "trst_open_drain") == 0)
1533 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1534 else if (strcmp(args[2], "trst_push_pull") == 0)
1535 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1536 else
1537 {
1538 ERROR("invalid reset_config argument, defaulting to none");
1539 jtag_reset_config = RESET_NONE;
1540 return ERROR_INVALID_ARGUMENTS;
1541 }
1542 }
1543
1544 if (argc >= 4)
1545 {
1546 if (strcmp(args[3], "srst_push_pull") == 0)
1547 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1548 else if (strcmp(args[3], "srst_open_drain") == 0)
1549 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1550 else
1551 {
1552 ERROR("invalid reset_config argument, defaulting to none");
1553 jtag_reset_config = RESET_NONE;
1554 return ERROR_INVALID_ARGUMENTS;
1555 }
1556 }
1557
1558 return ERROR_OK;
1559 }
1560
1561 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1562 {
1563 if (argc < 1)
1564 {
1565 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1566 exit(-1);
1567 }
1568 else
1569 {
1570 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1571 }
1572
1573 return ERROR_OK;
1574 }
1575
1576 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1577 {
1578 if (argc < 1)
1579 {
1580 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1581 exit(-1);
1582 }
1583 else
1584 {
1585 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1586 }
1587
1588 return ERROR_OK;
1589 }
1590
1591 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1592 {
1593 if (argc == 0)
1594 command_print(cmd_ctx, "jtag_speed: %i", jtag_speed);
1595
1596 if (argc > 0)
1597 {
1598 /* this command can be called during CONFIG,
1599 * in which case jtag isn't initialized */
1600 if (jtag)
1601 jtag->speed(strtoul(args[0], NULL, 0));
1602 else
1603 jtag_speed = strtoul(args[0], NULL, 0);
1604 }
1605
1606 return ERROR_OK;
1607 }
1608
1609 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1610 {
1611 enum tap_state state;
1612
1613 if (argc < 1)
1614 {
1615 return ERROR_COMMAND_SYNTAX_ERROR;
1616 }
1617 else
1618 {
1619 for (state = 0; state < 16; state++)
1620 {
1621 if (strcmp(args[0], tap_state_strings[state]) == 0)
1622 {
1623 jtag_add_end_state(state);
1624 jtag_execute_queue();
1625 }
1626 }
1627 }
1628 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]);
1629
1630 return ERROR_OK;
1631 }
1632
1633 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1634 {
1635 int trst = -1;
1636 int srst = -1;
1637 int retval;
1638
1639 if (argc < 2)
1640 {
1641 return ERROR_COMMAND_SYNTAX_ERROR;
1642
1643 }
1644
1645 if (args[0][0] == '1')
1646 trst = 1;
1647 else if (args[0][0] == '0')
1648 trst = 0;
1649 else
1650 {
1651 return ERROR_COMMAND_SYNTAX_ERROR;
1652 }
1653
1654 if (args[1][0] == '1')
1655 srst = 1;
1656 else if (args[1][0] == '0')
1657 srst = 0;
1658 else
1659 {
1660 return ERROR_COMMAND_SYNTAX_ERROR;
1661 }
1662
1663 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1664 return ERROR_JTAG_INIT_FAILED;
1665
1666 if ((retval = jtag_add_reset(trst, srst)) != ERROR_OK)
1667 {
1668 switch (retval)
1669 {
1670 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST:
1671 command_print(cmd_ctx, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args[1][0]);
1672 break;
1673 case ERROR_JTAG_RESET_CANT_SRST:
1674 command_print(cmd_ctx, "can't assert srst because the current reset_config doesn't support it");
1675 break;
1676 default:
1677 command_print(cmd_ctx, "unknown error");
1678 }
1679 }
1680 jtag_execute_queue();
1681
1682 return ERROR_OK;
1683 }
1684
1685 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1686 {
1687 if (argc < 1)
1688 {
1689 return ERROR_COMMAND_SYNTAX_ERROR;
1690 }
1691
1692 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
1693 jtag_execute_queue();
1694
1695 return ERROR_OK;
1696
1697 }
1698
1699 int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1700 {
1701 enum tap_state state;
1702
1703 state = -1;
1704 if (argc == 1)
1705 {
1706 for (state = 0; state < 16; state++)
1707 {
1708 if (strcmp(args[0], tap_state_strings[state]) == 0)
1709 {
1710 break;
1711 }
1712 }
1713 }
1714
1715 jtag_add_statemove(state);
1716 jtag_execute_queue();
1717
1718 return ERROR_OK;
1719
1720 }
1721
1722 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1723 {
1724 int i;
1725 scan_field_t *fields;
1726
1727 if ((argc < 2) || (argc % 2))
1728 {
1729 return ERROR_COMMAND_SYNTAX_ERROR;
1730 }
1731
1732 fields = malloc(sizeof(scan_field_t) * argc / 2);
1733
1734 for (i = 0; i < argc / 2; i++)
1735 {
1736 int device = strtoul(args[i*2], NULL, 0);
1737 int field_size = jtag_get_device(device)->ir_length;
1738 fields[i].device = device;
1739 fields[i].out_value = malloc(CEIL(field_size, 8));
1740 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
1741 fields[i].out_mask = NULL;
1742 fields[i].in_value = NULL;
1743 fields[i].in_check_mask = NULL;
1744 fields[i].in_handler = NULL;
1745 fields[i].in_handler_priv = NULL;
1746 }
1747
1748 jtag_add_ir_scan(argc / 2, fields, -1);
1749 jtag_execute_queue();
1750
1751 for (i = 0; i < argc / 2; i++)
1752 free(fields[i].out_value);
1753
1754 free (fields);
1755
1756 return ERROR_OK;
1757 }
1758
1759 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1760 {
1761 scan_field_t *fields;
1762 int num_fields = 0;
1763 int field_count = 0;
1764 var_t *var;
1765 int i, j;
1766
1767 if ((argc < 2) || (argc % 2))
1768 {
1769 return ERROR_COMMAND_SYNTAX_ERROR;
1770 }
1771
1772 for (i = 0; i < argc; i+=2)
1773 {
1774 var = get_var_by_namenum(args[i+1]);
1775 if (var)
1776 {
1777 num_fields += var->num_fields;
1778 }
1779 else
1780 {
1781 command_print(cmd_ctx, "variable %s doesn't exist", args[i+1]);
1782 return ERROR_OK;
1783 }
1784 }
1785
1786 fields = malloc(sizeof(scan_field_t) * num_fields);
1787
1788 for (i = 0; i < argc; i+=2)
1789 {
1790 var = get_var_by_namenum(args[i+1]);
1791
1792 for (j = 0; j < var->num_fields; j++)
1793 {
1794 fields[field_count].device = strtol(args[i], NULL, 0);
1795 fields[field_count].num_bits = var->fields[j].num_bits;
1796 fields[field_count].out_value = malloc(CEIL(var->fields[j].num_bits, 8));
1797 buf_set_u32(fields[field_count].out_value, 0, var->fields[j].num_bits, var->fields[j].value);
1798 fields[field_count].out_mask = NULL;
1799 fields[field_count].in_value = fields[field_count].out_value;
1800 fields[field_count].in_check_mask = NULL;
1801 fields[field_count].in_check_value = NULL;
1802 fields[field_count].in_handler = field_le_to_host;
1803 fields[field_count++].in_handler_priv = &(var->fields[j]);
1804 }
1805 }
1806
1807 jtag_add_dr_scan(num_fields, fields, -1);
1808 jtag_execute_queue();
1809
1810 for (i = 0; i < argc / 2; i++)
1811 free(fields[i].out_value);
1812
1813 free(fields);
1814
1815 return ERROR_OK;
1816 }
1817
1818 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1819 {
1820 if (argc == 1)
1821 {
1822 if (strcmp(args[0], "enable") == 0)
1823 {
1824 jtag_verify_capture_ir = 1;
1825 }
1826 else if (strcmp(args[0], "disable") == 0)
1827 {
1828 jtag_verify_capture_ir = 0;
1829 } else
1830 {
1831 return ERROR_COMMAND_SYNTAX_ERROR;
1832 }
1833 } else if (argc != 0)
1834 {
1835 return ERROR_COMMAND_SYNTAX_ERROR;
1836 }
1837
1838 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
1839
1840 return ERROR_OK;
1841 }
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)