Code Review / openocd.git / blob
? search:


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