Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Added patch to stop SEGFAULT with missing jtag config lines. Thanks Øyvind Harboe
[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 char* jtag_interface = NULL;
208 int jtag_speed = -1;
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, void *dummy_anachronism)
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, void *dummy_anachronism)
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, void *dummy_anachronism)
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 int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state, void *dummy_anachronism)
629 {
630 int i;
631 jtag_command_t **last_cmd = jtag_get_last_command_p();
632
633 if (jtag_trst == 1)
634 {
635 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
636 return ERROR_JTAG_TRST_ASSERTED;
637 }
638
639 /* allocate memory for a new list member */
640 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
641 last_comand_pointer = &((*last_cmd)->next);
642 (*last_cmd)->next = NULL;
643 (*last_cmd)->type = JTAG_SCAN;
644
645 /* allocate memory for scan command */
646 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
647 (*last_cmd)->cmd.scan->ir_scan = 0;
648 (*last_cmd)->cmd.scan->num_fields = num_fields;
649 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
650 (*last_cmd)->cmd.scan->end_state = state;
651
652 if (state != -1)
653 cmd_queue_end_state = state;
654
655 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
656 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
657
658 if (cmd_queue_end_state == TAP_TLR)
659 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
660
661 cmd_queue_cur_state = cmd_queue_end_state;
662
663 for (i = 0; i < num_fields; i++)
664 {
665 int num_bits = fields[i].num_bits;
666 int num_bytes = CEIL(fields[i].num_bits, 8);
667 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
668 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
669 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
670 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
671 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
672 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
673 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
674 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
675 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
676 }
677
678 return ERROR_OK;
679 }
680 int jtag_add_statemove(enum tap_state state)
681 {
682 jtag_command_t **last_cmd = jtag_get_last_command_p();
683
684 if (jtag_trst == 1)
685 {
686 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
687 return ERROR_JTAG_TRST_ASSERTED;
688 }
689
690 /* allocate memory for a new list member */
691 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
692 last_comand_pointer = &((*last_cmd)->next);
693 (*last_cmd)->next = NULL;
694 (*last_cmd)->type = JTAG_STATEMOVE;
695
696 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
697 (*last_cmd)->cmd.statemove->end_state = state;
698
699 if (state != -1)
700 cmd_queue_end_state = state;
701
702 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
703 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
704
705 if (cmd_queue_end_state == TAP_TLR)
706 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
707
708 cmd_queue_cur_state = cmd_queue_end_state;
709
710 return ERROR_OK;
711 }
712
713 int jtag_add_pathmove(int num_states, enum tap_state *path)
714 {
715 jtag_command_t **last_cmd = jtag_get_last_command_p();
716 int i;
717
718 if (jtag_trst == 1)
719 {
720 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
721 return ERROR_JTAG_TRST_ASSERTED;
722 }
723
724 /* the last state has to be a stable state */
725 if (tap_move_map[path[num_states - 1]] == -1)
726 {
727 ERROR("TAP path doesn't finish in a stable state");
728 return ERROR_JTAG_NOT_IMPLEMENTED;
729 }
730
731 if (jtag->support_pathmove)
732 {
733 /* allocate memory for a new list member */
734 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
735 last_comand_pointer = &((*last_cmd)->next);
736 (*last_cmd)->next = NULL;
737 (*last_cmd)->type = JTAG_PATHMOVE;
738
739 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
740 (*last_cmd)->cmd.pathmove->num_states = num_states;
741 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states);
742
743 for (i = 0; i < num_states; i++)
744 (*last_cmd)->cmd.pathmove->path[i] = path[i];
745 }
746 else
747 {
748 /* validate the desired path, and see if it fits a default path */
749 int begin = 0;
750 int end = 0;
751 int j;
752
753 for (i = 0; i < num_states; i++)
754 {
755 for (j = i; j < num_states; j++)
756 {
757 if (tap_move_map[path[j]] != -1)
758 {
759 end = j;
760 break;
761 }
762 }
763
764 if (begin - end <= 7) /* a default path spans no more than 7 states */
765 {
766 jtag_add_statemove(path[end]);
767 }
768 else
769 {
770 ERROR("encountered a TAP path that can't be fulfilled by default paths");
771 return ERROR_JTAG_NOT_IMPLEMENTED;
772 }
773
774 i = end;
775 }
776 }
777
778 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
779 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
780
781 if (cmd_queue_end_state == TAP_TLR)
782 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
783
784 cmd_queue_cur_state = path[num_states - 1];
785
786 return ERROR_OK;
787 }
788
789 int jtag_add_runtest(int num_cycles, enum tap_state state)
790 {
791 jtag_command_t **last_cmd = jtag_get_last_command_p();
792
793 if (jtag_trst == 1)
794 {
795 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
796 return ERROR_JTAG_TRST_ASSERTED;
797 }
798
799 /* allocate memory for a new list member */
800 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
801 (*last_cmd)->next = NULL;
802 last_comand_pointer = &((*last_cmd)->next);
803 (*last_cmd)->type = JTAG_RUNTEST;
804
805 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
806 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
807 (*last_cmd)->cmd.runtest->end_state = state;
808
809 if (state != -1)
810 cmd_queue_end_state = state;
811
812 if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR)
813 jtag_call_event_callbacks(JTAG_TRST_RELEASED);
814
815 if (cmd_queue_end_state == TAP_TLR)
816 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
817
818 cmd_queue_cur_state = cmd_queue_end_state;
819
820 return ERROR_OK;
821 }
822
823 int jtag_add_reset(int req_trst, int req_srst)
824 {
825 int trst_with_tms = 0;
826
827 jtag_command_t **last_cmd = jtag_get_last_command_p();
828
829 if (req_trst == -1)
830 req_trst = jtag_trst;
831
832 if (req_srst == -1)
833 req_srst = jtag_srst;
834
835 /* Make sure that jtag_reset_config allows the requested reset */
836 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
837 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (req_trst == 0))
838 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST;
839
840 /* if TRST pulls SRST, we reset with TAP T-L-R */
841 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_trst == 1)) && (req_srst == 0))
842 {
843 req_trst = 0;
844 trst_with_tms = 1;
845 }
846
847 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
848 {
849 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
850 return ERROR_JTAG_RESET_CANT_SRST;
851 }
852
853 if (req_trst && !(jtag_reset_config & RESET_HAS_TRST))
854 {
855 req_trst = 0;
856 trst_with_tms = 1;
857 }
858
859 /* allocate memory for a new list member */
860 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
861 (*last_cmd)->next = NULL;
862 last_comand_pointer = &((*last_cmd)->next);
863 (*last_cmd)->type = JTAG_RESET;
864
865 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
866 (*last_cmd)->cmd.reset->trst = req_trst;
867 (*last_cmd)->cmd.reset->srst = req_srst;
868
869 jtag_trst = req_trst;
870 jtag_srst = req_srst;
871
872 if (jtag_srst)
873 {
874 jtag_call_event_callbacks(JTAG_SRST_ASSERTED);
875 }
876 else
877 {
878 jtag_call_event_callbacks(JTAG_SRST_RELEASED);
879 if (jtag_nsrst_delay)
880 jtag_add_sleep(jtag_nsrst_delay * 1000);
881 }
882
883 if (trst_with_tms)
884 {
885 last_cmd = &((*last_cmd)->next);
886
887 /* allocate memory for a new list member */
888 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
889 (*last_cmd)->next = NULL;
890 last_comand_pointer = &((*last_cmd)->next);
891 (*last_cmd)->type = JTAG_STATEMOVE;
892
893 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
894 (*last_cmd)->cmd.statemove->end_state = TAP_TLR;
895
896 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
897 cmd_queue_cur_state = TAP_TLR;
898 cmd_queue_end_state = TAP_TLR;
899
900 return ERROR_OK;
901 }
902 else
903 {
904 if (jtag_trst)
905 {
906 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
907 * and inform possible listeners about this
908 */
909 cmd_queue_cur_state = TAP_TLR;
910 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
911 }
912 else
913 {
914 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
915 * but we might want to add a delay to give the TAP time to settle
916 */
917 if (jtag_ntrst_delay)
918 jtag_add_sleep(jtag_ntrst_delay * 1000);
919 }
920 }
921
922 return ERROR_OK;
923 }
924
925 int jtag_add_end_state(enum tap_state state)
926 {
927 jtag_command_t **last_cmd = jtag_get_last_command_p();
928
929 /* allocate memory for a new list member */
930 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
931 (*last_cmd)->next = NULL;
932 last_comand_pointer = &((*last_cmd)->next);
933 (*last_cmd)->type = JTAG_END_STATE;
934
935 (*last_cmd)->cmd.end_state = cmd_queue_alloc(sizeof(end_state_command_t));
936 (*last_cmd)->cmd.end_state->end_state = state;
937
938 if (state != -1)
939 cmd_queue_end_state = state;
940
941 return ERROR_OK;
942 }
943
944 int jtag_add_sleep(u32 us)
945 {
946 jtag_command_t **last_cmd = jtag_get_last_command_p();
947
948 /* allocate memory for a new list member */
949 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
950 (*last_cmd)->next = NULL;
951 last_comand_pointer = &((*last_cmd)->next);
952 (*last_cmd)->type = JTAG_SLEEP;
953
954 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
955 (*last_cmd)->cmd.sleep->us = us;
956
957 return ERROR_OK;
958 }
959
960 int jtag_scan_size(scan_command_t *cmd)
961 {
962 int bit_count = 0;
963 int i;
964
965 /* count bits in scan command */
966 for (i = 0; i < cmd->num_fields; i++)
967 {
968 bit_count += cmd->fields[i].num_bits;
969 }
970
971 return bit_count;
972 }
973
974 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
975 {
976 int bit_count = 0;
977 int i;
978
979 bit_count = jtag_scan_size(cmd);
980 *buffer = malloc(CEIL(bit_count, 8));
981
982 bit_count = 0;
983
984 for (i = 0; i < cmd->num_fields; i++)
985 {
986 if (cmd->fields[i].out_value)
987 {
988 #ifdef _DEBUG_JTAG_IO_
989 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16);
990 #endif
991 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
992 #ifdef _DEBUG_JTAG_IO_
993 DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
994 free(char_buf);
995 #endif
996 }
997
998 bit_count += cmd->fields[i].num_bits;
999 }
1000
1001 return bit_count;
1002
1003 }
1004
1005 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1006 {
1007 int i;
1008 int bit_count = 0;
1009 int retval;
1010
1011 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1012 retval = ERROR_OK;
1013
1014 for (i = 0; i < cmd->num_fields; i++)
1015 {
1016 /* if neither in_value nor in_handler
1017 * are specified we don't have to examine this field
1018 */
1019 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1020 {
1021 int num_bits = cmd->fields[i].num_bits;
1022 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1023
1024 #ifdef _DEBUG_JTAG_IO_
1025 char *char_buf;
1026
1027 char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1028 DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
1029 free(char_buf);
1030 #endif
1031
1032 if (cmd->fields[i].in_value)
1033 {
1034 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1035
1036 if (cmd->fields[i].in_handler)
1037 {
1038 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1039 {
1040 WARNING("in_handler reported a failed check");
1041 retval = ERROR_JTAG_QUEUE_FAILED;
1042 }
1043 }
1044 }
1045
1046 /* no in_value specified, but a handler takes care of the scanned data */
1047 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1048 {
1049 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1050 {
1051 /* We're going to call the error:handler later, but if the in_handler
1052 * reported an error we report this failure upstream
1053 */
1054 WARNING("in_handler reported a failed check");
1055 retval = ERROR_JTAG_QUEUE_FAILED;
1056 }
1057 }
1058
1059 free(captured);
1060 }
1061 bit_count += cmd->fields[i].num_bits;
1062 }
1063
1064 return retval;
1065 }
1066
1067 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1068 {
1069 int retval = ERROR_OK;
1070 int num_bits = field->num_bits;
1071
1072 int compare_failed = 0;
1073
1074 if (field->in_check_mask)
1075 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1076 else
1077 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1078
1079 if (compare_failed)
1080 {
1081 /* An error handler could have caught the failing check
1082 * only report a problem when there wasn't a handler, or if the handler
1083 * acknowledged the error
1084 */
1085 if (compare_failed)
1086 {
1087 char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1088 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16);
1089
1090 if (field->in_check_mask)
1091 {
1092 char *in_check_mask_char;
1093 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16);
1094 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);
1095 free(in_check_mask_char);
1096 }
1097 else
1098 {
1099 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char);
1100 }
1101
1102 free(captured_char);
1103 free(in_check_value_char);
1104 }
1105
1106 }
1107 return retval;
1108 }
1109
1110 /*
1111 set up checking of this field using the in_handler. The values passed in must be valid until
1112 after jtag_execute() has completed.
1113 */
1114 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1115 {
1116 if (value)
1117 field->in_handler = jtag_check_value;
1118 else
1119 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1120 field->in_handler_priv = NULL; /* this will be filled in at the invocation site to point to the field duplicate */
1121 field->in_check_value = value;
1122 field->in_check_mask = mask;
1123 }
1124
1125 enum scan_type jtag_scan_type(scan_command_t *cmd)
1126 {
1127 int i;
1128 int type = 0;
1129
1130 for (i = 0; i < cmd->num_fields; i++)
1131 {
1132 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1133 type |= SCAN_IN;
1134 if (cmd->fields[i].out_value)
1135 type |= SCAN_OUT;
1136 }
1137
1138 return type;
1139 }
1140
1141 int jtag_execute_queue(void)
1142 {
1143 int retval;
1144
1145 retval = jtag->execute_queue();
1146
1147 cmd_queue_free();
1148
1149 jtag_command_queue = NULL;
1150 last_comand_pointer = &jtag_command_queue;
1151
1152 return retval;
1153 }
1154
1155 int jtag_cancel_queue(void)
1156 {
1157 cmd_queue_free();
1158 jtag_command_queue = NULL;
1159 last_comand_pointer = &jtag_command_queue;
1160
1161 return ERROR_OK;
1162 }
1163
1164 int jtag_reset_callback(enum jtag_event event, void *priv)
1165 {
1166 jtag_device_t *device = priv;
1167
1168 DEBUG("-");
1169
1170 if (event == JTAG_TRST_ASSERTED)
1171 {
1172 buf_set_ones(device->cur_instr, device->ir_length);
1173 device->bypass = 1;
1174 }
1175
1176 return ERROR_OK;
1177 }
1178
1179 void jtag_sleep(u32 us)
1180 {
1181 usleep(us);
1182 }
1183
1184 /* Try to examine chain layout according to IEEE 1149.1 §12
1185 */
1186 int jtag_examine_chain()
1187 {
1188 jtag_device_t *device = jtag_devices;
1189 scan_field_t field;
1190 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1191 int i;
1192 int bit_count;
1193 int device_count = 0;
1194 u8 zero_check = 0x0;
1195 u8 one_check = 0xff;
1196
1197 field.device = 0;
1198 field.num_bits = sizeof(idcode_buffer) * 8;
1199 field.out_value = idcode_buffer;
1200 field.out_mask = NULL;
1201 field.in_value = idcode_buffer;
1202 field.in_check_value = NULL;
1203 field.in_check_mask = NULL;
1204 field.in_handler = NULL;
1205 field.in_handler_priv = NULL;
1206
1207 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1208 {
1209 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1210 }
1211
1212 jtag_add_plain_dr_scan(1, &field, TAP_TLR, NULL);
1213 jtag_execute_queue();
1214
1215 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1216 {
1217 zero_check |= idcode_buffer[i];
1218 one_check &= idcode_buffer[i];
1219 }
1220
1221 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1222 if ((zero_check == 0x00) || (one_check == 0xff))
1223 {
1224 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1225 return ERROR_JTAG_INIT_FAILED;
1226 }
1227
1228 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1229 {
1230 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1231 if ((idcode & 1) == 0)
1232 {
1233 /* LSB must not be 0, this indicates a device in bypass */
1234 device_count++;
1235
1236 bit_count += 1;
1237 }
1238 else
1239 {
1240 u32 manufacturer;
1241 u32 part;
1242 u32 version;
1243
1244 if (idcode == 0x000000FF)
1245 {
1246 /* End of chain (invalid manufacturer ID) */
1247 break;
1248 }
1249
1250 if (device)
1251 {
1252 device->idcode = idcode;
1253 device = device->next;
1254 }
1255 device_count++;
1256
1257 manufacturer = (idcode & 0xffe) >> 1;
1258 part = (idcode & 0xffff000) >> 12;
1259 version = (idcode & 0xf0000000) >> 28;
1260
1261 INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1262 idcode, manufacturer, part, version);
1263
1264 bit_count += 32;
1265 }
1266 }
1267
1268 /* see if number of discovered devices matches configuration */
1269 if (device_count != jtag_num_devices)
1270 {
1271 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1272 device_count, jtag_num_devices);
1273 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1274 return ERROR_JTAG_INIT_FAILED;
1275 }
1276
1277 return ERROR_OK;
1278 }
1279
1280 int jtag_validate_chain()
1281 {
1282 jtag_device_t *device = jtag_devices;
1283 int total_ir_length = 0;
1284 u8 *ir_test = NULL;
1285 scan_field_t field;
1286 int chain_pos = 0;
1287
1288 while (device)
1289 {
1290 total_ir_length += device->ir_length;
1291 device = device->next;
1292 }
1293
1294 total_ir_length += 2;
1295 ir_test = malloc(CEIL(total_ir_length, 8));
1296 buf_set_ones(ir_test, total_ir_length);
1297
1298 field.device = 0;
1299 field.num_bits = total_ir_length;
1300 field.out_value = ir_test;
1301 field.out_mask = NULL;
1302 field.in_value = ir_test;
1303 field.in_check_value = NULL;
1304 field.in_check_mask = NULL;
1305 field.in_handler = NULL;
1306 field.in_handler_priv = NULL;
1307
1308 jtag_add_plain_ir_scan(1, &field, TAP_TLR, NULL);
1309 jtag_execute_queue();
1310
1311 device = jtag_devices;
1312 while (device)
1313 {
1314 if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
1315 {
1316 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1317 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1318 free(cbuf);
1319 free(ir_test);
1320 return ERROR_JTAG_INIT_FAILED;
1321 }
1322 chain_pos += device->ir_length;
1323 device = device->next;
1324 }
1325
1326 if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
1327 {
1328 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1329 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1330 free(cbuf);
1331 free(ir_test);
1332 return ERROR_JTAG_INIT_FAILED;
1333 }
1334
1335 free(ir_test);
1336
1337 return ERROR_OK;
1338 }
1339
1340 int jtag_register_commands(struct command_context_s *cmd_ctx)
1341 {
1342 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1343 COMMAND_CONFIG, NULL);
1344 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1345 COMMAND_ANY, "set jtag speed (if supported) <speed>");
1346 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1347 COMMAND_CONFIG, NULL);
1348 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1349 COMMAND_CONFIG, NULL);
1350 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1351 COMMAND_CONFIG, NULL);
1352 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1353 COMMAND_CONFIG, NULL);
1354
1355 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1356 COMMAND_EXEC, "print current scan chain configuration");
1357
1358 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1359 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1360 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1361 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1362 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1363 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1364 register_command(cmd_ctx, NULL, "statemove", handle_statemove_command,
1365 COMMAND_EXEC, "move to current endstate or [tap_state]");
1366 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1367 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1368 register_command(cmd_ctx, NULL, "drscan", handle_drscan_command,
1369 COMMAND_EXEC, "execute DR scan <device> <var> [dev2] [var2] ...");
1370
1371 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1372 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1373 return ERROR_OK;
1374 }
1375
1376 int jtag_init(struct command_context_s *cmd_ctx)
1377 {
1378 int i, validate_tries = 0;
1379
1380 DEBUG("-");
1381
1382 if (jtag_speed == -1)
1383 jtag_speed = 0;
1384
1385 if (jtag_interface && (jtag_interface[0] != 0))
1386 /* configuration var 'jtag_interface' is set, and not empty */
1387 for (i = 0; jtag_interfaces[i]; i++)
1388 {
1389 if (strcmp(jtag_interface, jtag_interfaces[i]->name) == 0)
1390 {
1391 jtag_device_t *device;
1392 device = jtag_devices;
1393
1394 if (jtag_interfaces[i]->init() != ERROR_OK)
1395 return ERROR_JTAG_INIT_FAILED;
1396 jtag = jtag_interfaces[i];
1397
1398 jtag_ir_scan_size = 0;
1399 jtag_num_devices = 0;
1400 while (device != NULL)
1401 {
1402 jtag_ir_scan_size += device->ir_length;
1403 jtag_num_devices++;
1404 device = device->next;
1405 }
1406
1407 jtag_add_statemove(TAP_TLR);
1408 jtag_execute_queue();
1409
1410 /* examine chain first, as this could discover the real chain layout */
1411 if (jtag_examine_chain() != ERROR_OK)
1412 {
1413 ERROR("trying to validate configured JTAG chain anyway...");
1414 }
1415
1416 while (jtag_validate_chain() != ERROR_OK)
1417 {
1418 validate_tries++;
1419 if (validate_tries > 5)
1420 {
1421 ERROR("Could not validate JTAG chain, exit");
1422 jtag = NULL;
1423 return ERROR_JTAG_INVALID_INTERFACE;
1424 }
1425 usleep(10000);
1426 }
1427
1428 return ERROR_OK;
1429 }
1430 }
1431
1432 /* no valid interface was found (i.e. the configuration option,
1433 * didn't match one of the compiled-in interfaces
1434 */
1435 ERROR("No valid jtag interface found (%s)", jtag_interface);
1436 ERROR("compiled-in jtag interfaces:");
1437 for (i = 0; jtag_interfaces[i]; i++)
1438 {
1439 ERROR("%i: %s", i, jtag_interfaces[i]->name);
1440 }
1441
1442 jtag = NULL;
1443 return ERROR_JTAG_INVALID_INTERFACE;
1444 }
1445
1446 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1447 {
1448 int i;
1449
1450 /* only if the configuration var isn't overwritten from cmdline */
1451 if (!jtag_interface)
1452 {
1453 if (args[0] && (args[0][0] != 0))
1454 {
1455 for (i=0; jtag_interfaces[i]; i++)
1456 {
1457 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1458 {
1459 if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK)
1460 exit(-1);
1461
1462 jtag_interface = jtag_interfaces[i]->name;
1463
1464 return ERROR_OK;
1465 }
1466 }
1467 }
1468
1469 /* remember the requested interface name, so we can complain about it later */
1470 jtag_interface = strdup(args[0]);
1471 DEBUG("'interface' command didn't specify a valid interface");
1472 }
1473
1474 return ERROR_OK;
1475 }
1476
1477 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1478 {
1479 jtag_device_t **last_device_p = &jtag_devices;
1480
1481 if (*last_device_p)
1482 {
1483 while ((*last_device_p)->next)
1484 last_device_p = &((*last_device_p)->next);
1485 last_device_p = &((*last_device_p)->next);
1486 }
1487
1488 if (argc < 3)
1489 return ERROR_OK;
1490
1491 *last_device_p = malloc(sizeof(jtag_device_t));
1492 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1493
1494 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1495 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1496 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1497 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1498
1499 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1500 (*last_device_p)->bypass = 1;
1501 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1502
1503 (*last_device_p)->next = NULL;
1504
1505 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1506
1507 jtag_num_devices++;
1508
1509 return ERROR_OK;
1510 }
1511
1512 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1513 {
1514 jtag_device_t *device = jtag_devices;
1515 int device_count = 0;
1516
1517 while (device)
1518 {
1519 u32 expected, expected_mask, cur_instr;
1520 expected = buf_get_u32(device->expected, 0, device->ir_length);
1521 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1522 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1523 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);
1524 device = device->next;
1525 device_count++;
1526 }
1527
1528 return ERROR_OK;
1529 }
1530
1531 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1532 {
1533 if (argc >= 1)
1534 {
1535 if (strcmp(args[0], "none") == 0)
1536 jtag_reset_config = RESET_NONE;
1537 else if (strcmp(args[0], "trst_only") == 0)
1538 jtag_reset_config = RESET_HAS_TRST;
1539 else if (strcmp(args[0], "srst_only") == 0)
1540 jtag_reset_config = RESET_HAS_SRST;
1541 else if (strcmp(args[0], "trst_and_srst") == 0)
1542 jtag_reset_config = RESET_TRST_AND_SRST;
1543 else
1544 {
1545 ERROR("invalid reset_config argument, defaulting to none");
1546 jtag_reset_config = RESET_NONE;
1547 return ERROR_INVALID_ARGUMENTS;
1548 }
1549 }
1550
1551 if (argc >= 2)
1552 {
1553 if (strcmp(args[1], "srst_pulls_trst") == 0)
1554 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1555 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1556 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1557 else if (strcmp(args[1], "combined") == 0)
1558 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1559 else if (strcmp(args[1], "separate") == 0)
1560 jtag_reset_config &= ~(RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST);
1561 else
1562 {
1563 ERROR("invalid reset_config argument, defaulting to none");
1564 jtag_reset_config = RESET_NONE;
1565 return ERROR_INVALID_ARGUMENTS;
1566 }
1567 }
1568
1569 if (argc >= 3)
1570 {
1571 if (strcmp(args[2], "trst_open_drain") == 0)
1572 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1573 else if (strcmp(args[2], "trst_push_pull") == 0)
1574 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1575 else
1576 {
1577 ERROR("invalid reset_config argument, defaulting to none");
1578 jtag_reset_config = RESET_NONE;
1579 return ERROR_INVALID_ARGUMENTS;
1580 }
1581 }
1582
1583 if (argc >= 4)
1584 {
1585 if (strcmp(args[3], "srst_push_pull") == 0)
1586 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1587 else if (strcmp(args[3], "srst_open_drain") == 0)
1588 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1589 else
1590 {
1591 ERROR("invalid reset_config argument, defaulting to none");
1592 jtag_reset_config = RESET_NONE;
1593 return ERROR_INVALID_ARGUMENTS;
1594 }
1595 }
1596
1597 return ERROR_OK;
1598 }
1599
1600 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1601 {
1602 if (argc < 1)
1603 {
1604 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1605 exit(-1);
1606 }
1607 else
1608 {
1609 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1610 }
1611
1612 return ERROR_OK;
1613 }
1614
1615 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1616 {
1617 if (argc < 1)
1618 {
1619 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1620 exit(-1);
1621 }
1622 else
1623 {
1624 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1625 }
1626
1627 return ERROR_OK;
1628 }
1629
1630 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1631 {
1632 if (argc == 0)
1633 command_print(cmd_ctx, "jtag_speed: %i", jtag_speed);
1634
1635 if (argc > 0)
1636 {
1637 /* this command can be called during CONFIG,
1638 * in which case jtag isn't initialized */
1639 if (jtag)
1640 jtag->speed(strtoul(args[0], NULL, 0));
1641 else
1642 jtag_speed = strtoul(args[0], NULL, 0);
1643 }
1644
1645 return ERROR_OK;
1646 }
1647
1648 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1649 {
1650 enum tap_state state;
1651
1652 if (argc < 1)
1653 {
1654 command_print(cmd_ctx, "usage: endstate <tap_state>");
1655 }
1656 else
1657 {
1658 for (state = 0; state < 16; state++)
1659 {
1660 if (strcmp(args[0], tap_state_strings[state]) == 0)
1661 {
1662 jtag_add_end_state(state);
1663 jtag_execute_queue();
1664 }
1665 }
1666 }
1667 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]);
1668
1669 return ERROR_OK;
1670 }
1671
1672 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1673 {
1674 int trst = -1;
1675 int srst = -1;
1676 char *usage = "usage: jtag_reset <trst> <srst>";
1677 int retval;
1678
1679 if (argc < 1)
1680 {
1681 command_print(cmd_ctx, usage);
1682 return ERROR_OK;
1683 }
1684
1685 if (args[0][0] == '1')
1686 trst = 1;
1687 else if (args[0][0] == '0')
1688 trst = 0;
1689 else
1690 {
1691 command_print(cmd_ctx, usage);
1692 return ERROR_OK;
1693 }
1694
1695 if (args[1][0] == '1')
1696 srst = 1;
1697 else if (args[1][0] == '0')
1698 srst = 0;
1699 else
1700 {
1701 command_print(cmd_ctx, usage);
1702 return ERROR_OK;
1703 }
1704
1705 if ((retval = jtag_add_reset(trst, srst)) != ERROR_OK)
1706 {
1707 switch (retval)
1708 {
1709 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST:
1710 command_print(cmd_ctx, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args[1][0]);
1711 break;
1712 case ERROR_JTAG_RESET_CANT_SRST:
1713 command_print(cmd_ctx, "can't assert srst because the current reset_config doesn't support it");
1714 break;
1715 default:
1716 command_print(cmd_ctx, "unknown error");
1717 }
1718 }
1719 jtag_execute_queue();
1720
1721 return ERROR_OK;
1722 }
1723
1724 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1725 {
1726 if (argc < 1)
1727 {
1728 command_print(cmd_ctx, "usage: runtest <num_cycles>");
1729 return ERROR_OK;
1730 }
1731
1732 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
1733 jtag_execute_queue();
1734
1735 return ERROR_OK;
1736
1737 }
1738
1739 int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1740 {
1741 enum tap_state state;
1742
1743 state = -1;
1744 if (argc == 1)
1745 {
1746 for (state = 0; state < 16; state++)
1747 {
1748 if (strcmp(args[0], tap_state_strings[state]) == 0)
1749 {
1750 break;
1751 }
1752 }
1753 }
1754
1755 jtag_add_statemove(state);
1756 jtag_execute_queue();
1757
1758 return ERROR_OK;
1759
1760 }
1761
1762 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1763 {
1764 int i;
1765 scan_field_t *fields;
1766
1767 if ((argc < 2) || (argc % 2))
1768 {
1769 command_print(cmd_ctx, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1770 return ERROR_OK;
1771 }
1772
1773 fields = malloc(sizeof(scan_field_t) * argc / 2);
1774
1775 for (i = 0; i < argc / 2; i++)
1776 {
1777 int device = strtoul(args[i*2], NULL, 0);
1778 int field_size = jtag_get_device(device)->ir_length;
1779 fields[i].device = device;
1780 fields[i].out_value = malloc(CEIL(field_size, 8));
1781 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
1782 fields[i].out_mask = NULL;
1783 fields[i].in_value = NULL;
1784 fields[i].in_check_mask = NULL;
1785 fields[i].in_handler = NULL;
1786 fields[i].in_handler_priv = NULL;
1787 }
1788
1789 jtag_add_ir_scan(argc / 2, fields, -1, NULL);
1790 jtag_execute_queue();
1791
1792 for (i = 0; i < argc / 2; i++)
1793 free(fields[i].out_value);
1794
1795 free (fields);
1796
1797 return ERROR_OK;
1798 }
1799
1800 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1801 {
1802 scan_field_t *fields;
1803 int num_fields = 0;
1804 int field_count = 0;
1805 var_t *var;
1806 int i, j;
1807
1808 if ((argc < 2) || (argc % 2))
1809 {
1810 command_print(cmd_ctx, "usage: drscan <device> <var> [dev2] [var2]");
1811 return ERROR_OK;
1812 }
1813
1814 for (i = 0; i < argc; i+=2)
1815 {
1816 var = get_var_by_namenum(args[i+1]);
1817 if (var)
1818 {
1819 num_fields += var->num_fields;
1820 }
1821 else
1822 {
1823 command_print(cmd_ctx, "variable %s doesn't exist", args[i+1]);
1824 return ERROR_OK;
1825 }
1826 }
1827
1828 fields = malloc(sizeof(scan_field_t) * num_fields);
1829
1830 for (i = 0; i < argc; i+=2)
1831 {
1832 var = get_var_by_namenum(args[i+1]);
1833
1834 for (j = 0; j < var->num_fields; j++)
1835 {
1836 fields[field_count].device = strtol(args[i], NULL, 0);
1837 fields[field_count].num_bits = var->fields[j].num_bits;
1838 fields[field_count].out_value = malloc(CEIL(var->fields[j].num_bits, 8));
1839 buf_set_u32(fields[field_count].out_value, 0, var->fields[j].num_bits, var->fields[j].value);
1840 fields[field_count].out_mask = NULL;
1841 fields[field_count].in_value = fields[field_count].out_value;
1842 fields[field_count].in_check_mask = NULL;
1843 fields[field_count].in_check_value = NULL;
1844 fields[field_count].in_handler = field_le_to_host;
1845 fields[field_count++].in_handler_priv = &(var->fields[j]);
1846 }
1847 }
1848
1849 jtag_add_dr_scan(num_fields, fields, -1, NULL);
1850 jtag_execute_queue();
1851
1852 for (i = 0; i < argc / 2; i++)
1853 free(fields[i].out_value);
1854
1855 free(fields);
1856
1857 return ERROR_OK;
1858 }
1859
1860 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1861 {
1862 if (argc == 0)
1863 {
1864 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
1865 return ERROR_OK;
1866 }
1867
1868 if (strcmp(args[0], "enable") == 0)
1869 {
1870 jtag_verify_capture_ir = 1;
1871 }
1872 else if (strcmp(args[0], "disable") == 0)
1873 {
1874 jtag_verify_capture_ir = 0;
1875 }
1876
1877 return ERROR_OK;
1878 }
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)