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

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)