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