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